prisma · StevenMcClankerton · Aug 28, 2026 · Aug 28, 2026 · Aug 28, 2026 · Aug 28, 2026
@@ -16,6 +16,7 @@ export type {
   PslExtensionBlockParamRef,
   PslExtensionBlockParamScalarValue,
   PslExtensionBlockParamValue,
+  PslExtensionBlockParsedAttribute,
   PslPosition,
   PslSpan,
 } from '../shared/psl-extension-block';

@@ -63,4 +63,5 @@ export type {
   PslExtensionBlockParamRef,
   PslExtensionBlockParamScalarValue,
   PslExtensionBlockParamValue,
+  PslExtensionBlockParsedAttribute,
 } from '../shared/psl-extension-block';
@@ -330,7 +330,7 @@ export function resolveEnumCodecId(
   ctx: AuthoringEntityContext,
 ): { readonly codecId: string; readonly codecSpan: PslSpan } | undefined {
   const sourceId = ctx.sourceId ?? 'unknown';
-  const typeAttr = block.blockAttributes.find((a) => a.name === 'type');
+  const typeAttr = block.attributes['type'];
 
   if (typeAttr === undefined) {
     const inferredKind = classifyEnumMemberType(block);
@@ -346,12 +346,8 @@ export function resolveEnumCodecId(
     return { codecId: ctx.enumInferenceCodecs[inferredKind], codecSpan: block.span };
   }
 
-  const rawCodecArg = typeAttr.args[0]?.value;
-  const codecId =
-    rawCodecArg?.startsWith('"') && rawCodecArg.endsWith('"') && rawCodecArg.length >= 2
-      ? rawCodecArg.slice(1, -1)
-      : undefined;
-  if (codecId === undefined) {
+  const codecId = typeAttr.args['codecId'];
+  if (typeof codecId !== 'string') {
     ctx.diagnostics?.push({
       code: 'PSL_ENUM_MISSING_TYPE',
       message: `enum "${block.name}" @@type attribute must have a quoted codec id argument`,
@@ -360,7 +356,7 @@ export function resolveEnumCodecId(
     });
     return undefined;
   }
-  return { codecId, codecSpan: typeAttr.args[0]?.span ?? typeAttr.span };
+  return { codecId, codecSpan: typeAttr.span };
 }
 
 export interface AuthoringEntityTypeTemplateOutput {
@@ -464,6 +460,7 @@ export interface AuthoringPslBlockDescriptor {
     readonly parameter: string;
     readonly attribute: string;
   };
+  readonly attributes?: Readonly<Record<string, unknown>>;
 }
 
 export type AuthoringPslBlockDescriptorNamespace = {
@@ -735,7 +732,12 @@ function isWellFormedDescriptor(value: unknown, descriptorKind: string): boolean
       if (!('required' in name) || typeof name.required !== 'boolean') return false;
       if (!('parameters' in value)) return false;
       const parameters = value.parameters;
-      return typeof parameters === 'object' && parameters !== null && !Array.isArray(parameters);
+      if (typeof parameters !== 'object' || parameters === null || Array.isArray(parameters)) {
+        return false;
+      }
+      if (!('attributes' in value) || value.attributes === undefined) return true;
+      const attributes = value.attributes;
+      return typeof attributes === 'object' && attributes !== null && !Array.isArray(attributes);
     }
     case 'modelAttribute': {
       if (

@@ -111,6 +111,7 @@ export type PslDiagnosticCode =
    * A `@@`-prefixed block-attribute line inside an extension block has invalid syntax.
    */
   | 'PSL_INVALID_EXTENSION_BLOCK_ATTRIBUTE'
+  | 'PSL_EXTENSION_UNKNOWN_BLOCK_ATTRIBUTE'
   /**
    * Duplicate scopes are top level, namespace body, or block fields; diagnostics
    * are first-wins and anchored on later name spans.
@@ -251,6 +252,11 @@ export interface PslExtensionBlockAttribute {
   readonly span: PslSpan;
 }
 
+export interface PslExtensionBlockParsedAttribute {
+  readonly args: Readonly<Record<string, unknown>>;
+  readonly span: PslSpan;
+}
+
 /**
  * Base shape for a uniform extension-contributed top-level PSL block
  * node, as produced by the generic framework parser and consumed by the
@@ -294,5 +300,6 @@ export interface PslExtensionBlock {
   readonly name: string;
   readonly parameters: Record<string, PslExtensionBlockParamValue>;
   readonly blockAttributes: readonly PslExtensionBlockAttribute[];
+  readonly attributes: Readonly<Record<string, PslExtensionBlockParsedAttribute>>;
   readonly span: PslSpan;
 }
@@ -722,6 +722,48 @@ describe('assembleAuthoringContributions', () => {
     ).toThrow(/Malformed authoring pslBlock contribution at "broken"/);
   });
 
+  it('keeps a pslBlockDescriptors entry that declares block attributes', () => {
+    const mapFactory = () => ({ level: 'block', name: 'map' });
+    const result = assembleAuthoringContributions([
+      createDescriptor({
+        authoring: {
+          entityTypes: {
+            foo: { kind: 'entity', discriminator: 'fake-foo', output: { factory: () => ({}) } },
+          },
+          pslBlockDescriptors: {
+            fooBlock: {
+              ...makeDeclarativePslBlockDescriptor('fake-foo'),
+              attributes: { map: mapFactory },
+            },
+          },
+        },
+      }),
+    ]);
+    expect(result.pslBlockDescriptors['fooBlock']).toMatchObject({
+      attributes: { map: mapFactory },
+    });
+  });
+
+  it('rejects a pslBlockDescriptors entry whose attributes is not a record', () => {
+    expect(() =>
+      assembleAuthoringContributions([
+        createDescriptor({
+          authoring: {
+            entityTypes: {
+              foo: { kind: 'entity', discriminator: 'fake-foo', output: { factory: () => ({}) } },
+            },
+            pslBlockDescriptors: {
+              fooBlock: {
+                ...makeDeclarativePslBlockDescriptor('fake-foo'),
+                attributes: 'map',
+              } as unknown as never,
+            },
+          },
+        }),
+      ]),
+    ).toThrow(/Malformed authoring pslBlock contribution at "fooBlock"/);
+  });
+
   it('descends into a pslBlockDescriptors sub-namespace whose key is "kind" or "discriminator" without triggering malformed check', () => {
     // A sub-namespace keyed "kind" or "discriminator" that does not itself
     // look like a descriptor must descend normally.

@@ -983,6 +983,7 @@ describe('classifyEnumMemberType', () => {
       name: 'TestEnum',
       parameters,
       blockAttributes: [],
+      attributes: {},
       span: testSpan,
     };
   }

@@ -21,7 +21,15 @@ function makeExtensionBlock(
   name: string,
   keyword: string = discriminator,
 ): PslExtensionBlock {
-  return { kind: discriminator, keyword, name, parameters: {}, blockAttributes: [], span: SPAN };
+  return {
+    kind: discriminator,
+    keyword,
+    name,
+    parameters: {},
+    blockAttributes: [],
+    attributes: {},
+    span: SPAN,
+  };
 }
 
 describe('makePslNamespace / makePslNamespaceEntries', () => {

@@ -11,6 +11,8 @@ import type {
   PslBlockParamOption,
   PslBlockParamRef,
   PslBlockParamValue,
+  PslExtensionBlock,
+  PslExtensionBlockParsedAttribute,
 } from '../src/shared/psl-extension-block';
 
 describe('PslBlockParam discriminated union', () => {
@@ -157,3 +159,30 @@ describe('isAuthoringPslBlockDescriptor', () => {
     }
   });
 });
+
+describe('block attributes', () => {
+  it('a descriptor declares its block attributes as erased factories, sibling of parameters', () => {
+    const descriptor = {
+      kind: 'pslBlock',
+      keyword: 'native_enum',
+      discriminator: 'native_enum',
+      name: { required: true },
+      parameters: {},
+      attributes: { map: () => ({ level: 'block', name: 'map' }) },
+    } as const;
+    expectTypeOf(descriptor).toMatchTypeOf<AuthoringPslBlockDescriptor>();
+    expectTypeOf<AuthoringPslBlockDescriptor['attributes']>().toEqualTypeOf<
+      Readonly<Record<string, unknown>> | undefined
+    >();
+  });
+
+  it('a block node carries its parsed attributes as plain data keyed by attribute name', () => {
+    expectTypeOf<PslExtensionBlock['attributes']>().toEqualTypeOf<
+      Readonly<Record<string, PslExtensionBlockParsedAttribute>>
+    >();
+    expectTypeOf<PslExtensionBlockParsedAttribute['args']>().toEqualTypeOf<
+      Readonly<Record<string, unknown>>
+    >();
+    expectTypeOf<Omit<PslExtensionBlock, 'attributes'>>().not.toMatchTypeOf<PslExtensionBlock>();
+  });
+});
@@ -127,6 +127,7 @@ function validNode(): PslExtensionBlock {
       using: { kind: 'value', raw: '"auth.uid() = user_id"', span: stubSpan() },
     },
     blockAttributes: [],
+    attributes: {},
   };
 }
 
@@ -511,6 +512,7 @@ describe('validateExtensionBlock', () => {
             target: { kind: 'ref', identifier: 'Post', span: stubSpan() },
           },
           blockAttributes: [],
+          attributes: {},
         };
 
         const diagnostics = validateExtensionBlock(
@@ -550,6 +552,7 @@ describe('validateExtensionBlock', () => {
             target: { kind: 'ref', identifier: 'Ghost', span: stubSpan() },
           },
           blockAttributes: [],
+          attributes: {},
         };
 
         const diagnostics = validateExtensionBlock(
@@ -638,6 +641,7 @@ describe('validateExtensionBlock', () => {
           },
         },
         blockAttributes: [],
+        attributes: {},
       };
 
       const diagnostics = validateExtensionBlock(node, listDescriptor, SOURCE_ID, codecLookup);
@@ -686,6 +690,7 @@ describe('validateExtensionBlock', () => {
           using: { kind: 'value', raw: 'not_quoted', span: stubSpan() },
         },
         blockAttributes: [],
+        attributes: {},
         // target (required) is missing
         // using (required) — present but invalid
       };

@@ -0,0 +1,38 @@
+import type { PslDiagnostic } from '@internal/framework-components/psl-ast';
+import type { AstNode } from '../syntax/ast-helpers';
+import type {
+  AttributeOut,
+  AttributeSpec,
+  BlockInterpretCtx,
+  Param,
+  PositionalParam,
+} from './types';
+
+interface BlockAttributeConfig<
+  Pos extends readonly PositionalParam<unknown, BlockInterpretCtx>[],
+  Named extends Record<string, Param<unknown, BlockInterpretCtx>>,
+> {
+  readonly positional?: Pos;
+  readonly named?: Named;
+  readonly refine?: (
+    parsed: AttributeOut<Pos, Named>,
+    ctx: BlockInterpretCtx,
+    attributeNode: AstNode,
+  ) => readonly PslDiagnostic[];
+}
+
+export function blockAttribute<
+  const Pos extends readonly PositionalParam<unknown, BlockInterpretCtx>[] = readonly [],
+  const Named extends Record<string, Param<unknown, BlockInterpretCtx>> = Record<never, never>,
+>(
+  name: string,
+  config: BlockAttributeConfig<Pos, Named>,
+): AttributeSpec<AttributeOut<Pos, Named>, BlockInterpretCtx> {
+  return {
+    level: 'block',
+    name,
+    positional: config.positional ?? [],
+    named: config.named ?? {},
+    ...(config.refine !== undefined ? { refine: config.refine } : {}),
+  };
+}
@@ -1,16 +1,17 @@
 import type { PslDiagnostic } from '@internal/framework-components/psl-ast';
 import { notOk, ok, type Result } from '@internal/utils/result';
 import { BooleanLiteralExprAst } from '../../syntax/ast/expressions';
-import type { ArgType } from '../types';
+import type { ArgType, BlockInterpretCtx } from '../types';
 import { leafDiagnostic } from './diagnostic';
 
-export function bool(): ArgType<boolean> {
+export function bool(): ArgType<boolean, BlockInterpretCtx> {
   return {
     kind: 'bool',
     label: 'boolean',
     parse: (arg, ctx): Result<boolean, readonly PslDiagnostic[]> => {
-      if (arg instanceof BooleanLiteralExprAst) {
-        const value = arg.value();
+      const literal = BooleanLiteralExprAst.cast(arg.syntax);
+      if (literal !== undefined) {
+        const value = literal.value();
         if (value !== undefined) return ok(value);
       }
       return notOk([leafDiagnostic(ctx, arg, 'Expected a boolean literal')]);

@@ -1,12 +1,12 @@
 import type { PslDiagnostic, PslDiagnosticCode } from '@internal/framework-components/psl-ast';
 import { nodePslSpan } from '../../resolve';
 import type { AstNode } from '../../syntax/ast-helpers';
-import type { InterpretCtx } from '../types';
+import type { BlockInterpretCtx } from '../types';
 
 export const ATTRIBUTE_DIAGNOSTIC_CODE: PslDiagnosticCode = 'PSL_INVALID_ATTRIBUTE_SYNTAX';
 
 export function leafDiagnostic(
-  ctx: InterpretCtx,
+  ctx: BlockInterpretCtx,
   node: AstNode,
   message: string,
   code: PslDiagnostic['code'] = ATTRIBUTE_DIAGNOSTIC_CODE,

@@ -11,10 +11,7 @@ export function entityRef(): ArgType<string> {
     kind: 'entityRef',
     label: 'model name',
     parse: (arg, ctx): Result<string, readonly PslDiagnostic[]> => {
-      if (!(arg instanceof IdentifierAst)) {
-        return notOk([leafDiagnostic(ctx, arg, 'Expected a model name')]);
-      }
-      const name = arg.name();
+      const name = IdentifierAst.cast(arg.syntax)?.name();
       if (name === undefined) {
         return notOk([leafDiagnostic(ctx, arg, 'Expected a model name')]);
       }

@@ -16,10 +16,7 @@ export function fieldRef(scope: FieldRefScope): FieldRefArgType {
     label: 'field name',
     scope,
     parse: (arg, ctx): Result<string, readonly PslDiagnostic[]> => {
-      if (!(arg instanceof IdentifierAst)) {
-        return notOk([leafDiagnostic(ctx, arg, 'Expected a field name')]);
-      }
-      const name = arg.name();
+      const name = IdentifierAst.cast(arg.syntax)?.name();
       if (name === undefined) {
         return notOk([leafDiagnostic(ctx, arg, 'Expected a field name')]);
       }

@@ -47,10 +47,11 @@ function matchCallee(
   name: string,
   ctx: InterpretCtx,
 ): Result<FunctionCallAst, readonly PslDiagnostic[]> {
-  if (!(arg instanceof FunctionCallAst)) {
+  const call = FunctionCallAst.cast(arg.syntax);
+  if (call === undefined) {
     return notOk([leafDiagnostic(ctx, arg, 'Expected a function call')]);
   }
-  const qname = arg.name();
+  const qname = call.name();
   if (qname === undefined || qname.dot() !== undefined || qname.colon() !== undefined) {
     return notOk([leafDiagnostic(ctx, arg, 'Expected a function call')]);
   }
@@ -61,5 +62,5 @@ function matchCallee(
   if (calleeName !== name) {
     return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
   }
-  return ok(arg);
+  return ok(call);
 }
@@ -1,15 +1,15 @@
 import type { PslDiagnostic } from '@internal/framework-components/psl-ast';
 import { notOk, ok, type Result } from '@internal/utils/result';
 import { IdentifierAst } from '../../syntax/ast/identifier';
-import type { ArgType } from '../types';
+import type { ArgType, BlockInterpretCtx } from '../types';
 import { leafDiagnostic } from './diagnostic';
 
-export function identifier<const N extends string>(name: N): ArgType<N> {
+export function identifier<const N extends string>(name: N): ArgType<N, BlockInterpretCtx> {
   return {
     kind: 'identifier',
     label: name,
     parse: (arg, ctx): Result<N, readonly PslDiagnostic[]> => {
-      if (arg instanceof IdentifierAst && arg.name() === name) return ok(name);
+      if (IdentifierAst.cast(arg.syntax)?.name() === name) return ok(name);
       return notOk([leafDiagnostic(ctx, arg, `Expected ${name}`)]);
     },
   };