@prisma-next/framework-components 0.13.0-dev.2 → 0.13.0-dev.20

package/dist/psl-ast.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"psl-ast.mjs","names":[],"sources":["../src/control/psl-ast.ts","../src/control/psl-extension-block-validator.ts"],"sourcesContent":["export type { AuthoringPslBlockDescriptorNamespace } from '../shared/framework-authoring';\nexport type {\n  PslBlockParam,\n  PslBlockParamList,\n  PslBlockParamOption,\n  PslBlockParamRef,\n  PslBlockParamValue,\n  PslDiagnosticCode,\n  PslExtensionBlock,\n  PslExtensionBlockParamList,\n  PslExtensionBlockParamOption,\n  PslExtensionBlockParamRef,\n  PslExtensionBlockParamScalarValue,\n  PslExtensionBlockParamValue,\n  PslPosition,\n  PslSpan,\n} from '../shared/psl-extension-block';\n\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { CodecLookup } from '../shared/codec-types';\nimport type { AuthoringPslBlockDescriptorNamespace } from '../shared/framework-authoring';\nimport type { PslDiagnosticCode, PslExtensionBlock, PslSpan } from '../shared/psl-extension-block';\n\nexport interface PslDiagnostic {\n  readonly code: PslDiagnosticCode;\n  readonly message: string;\n  readonly sourceId: string;\n  readonly span: PslSpan;\n}\n\nexport interface PslDefaultFunctionValue {\n  readonly kind: 'function';\n  readonly name: 'autoincrement' | 'now';\n}\n\nexport interface PslDefaultLiteralValue {\n  readonly kind: 'literal';\n  readonly value: string | number | boolean;\n}\n\nexport type PslDefaultValue = PslDefaultFunctionValue | PslDefaultLiteralValue;\n\nexport type PslAttributeTarget = 'field' | 'model' | 'enum' | 'namedType';\n\nexport interface PslAttributePositionalArgument {\n  readonly kind: 'positional';\n  readonly value: string;\n  readonly span: PslSpan;\n}\n\nexport interface PslAttributeNamedArgument {\n  readonly kind: 'named';\n  readonly name: string;\n  readonly value: string;\n  readonly span: PslSpan;\n}\n\nexport type PslAttributeArgument = PslAttributePositionalArgument | PslAttributeNamedArgument;\n\nexport interface PslTypeConstructorCall {\n  readonly kind: 'typeConstructor';\n  readonly path: readonly string[];\n  readonly args: readonly PslAttributeArgument[];\n  readonly span: PslSpan;\n}\n\nexport interface PslAttribute {\n  readonly kind: 'attribute';\n  readonly target: PslAttributeTarget;\n  readonly name: string;\n  readonly args: readonly PslAttributeArgument[];\n  readonly span: PslSpan;\n}\n\nexport type PslReferentialAction = string;\n\nexport type PslFieldAttribute = PslAttribute;\n\nexport interface PslField {\n  readonly kind: 'field';\n  readonly name: string;\n  /** Unqualified type name, e.g. `\"User\"` for both `User`, `auth.User`, and `supabase:auth.User`. */\n  readonly typeName: string;\n  /** Namespace qualifier from a dot-qualified type reference, e.g. `\"auth\"` for `auth.User` or `supabase:auth.User`. Absent for unqualified types. */\n  readonly typeNamespaceId?: string;\n  /**\n   * Contract-space qualifier from a colon-prefix type reference, e.g. `\"supabase\"` for\n   * `supabase:auth.User` or `supabase:User`. Absent for local (same-space) type references.\n   *\n   * When present, the field references a model from a different contract space. The namespace\n   * (`typeNamespaceId`) and model name (`typeName`) identify the target within that space.\n   * Physical table resolution against the extension contract is deferred to the aggregate stage (M3).\n   */\n  readonly typeContractSpaceId?: string;\n  readonly typeConstructor?: PslTypeConstructorCall;\n  readonly optional: boolean;\n  readonly list: boolean;\n  readonly typeRef?: string;\n  readonly attributes: readonly PslFieldAttribute[];\n  readonly span: PslSpan;\n}\n\nexport interface PslUniqueConstraint {\n  readonly kind: 'unique';\n  readonly fields: readonly string[];\n  readonly span: PslSpan;\n}\n\nexport interface PslIndexConstraint {\n  readonly kind: 'index';\n  readonly fields: readonly string[];\n  readonly span: PslSpan;\n}\n\nexport type PslModelAttribute = PslAttribute;\n\nexport interface PslModel {\n  readonly kind: 'model';\n  readonly name: string;\n  readonly fields: readonly PslField[];\n  readonly attributes: readonly PslModelAttribute[];\n  readonly span: PslSpan;\n  /**\n   * Optional leading comment line emitted above the `model` keyword by the\n   * printer. Producers (e.g. `sqlSchemaIrToPslAst`) attach introspection\n   * advisories such as \"// WARNING: This table has no primary key in the\n   * database\" here. The parser leaves this field unset; round-tripping a\n   * parsed schema does not re-attach comments.\n   */\n  readonly comment?: string;\n}\n\nexport interface PslEnumValue {\n  readonly kind: 'enumValue';\n  readonly name: string;\n  /**\n   * Optional storage label for the enum member, captured from a trailing\n   * `@map(\"...\")` attribute on the member line. The parser populates this\n   * when the source PSL carries an explicit `@map`. Producers (e.g.\n   * `sqlSchemaIrToPslAst`) leave it unset; the printer emits `@map(...)`\n   * automatically when normalisation would change the printed member name\n   * (so an enum value `'in-progress'` becomes `inProgress @map(\"in-progress\")`\n   * in PSL, preserving the round-trip).\n   */\n  readonly mapName?: string;\n  readonly span: PslSpan;\n}\n\nexport interface PslEnum {\n  readonly kind: 'enum';\n  readonly name: string;\n  readonly values: readonly PslEnumValue[];\n  readonly attributes: readonly PslAttribute[];\n  readonly span: PslSpan;\n}\n\n/**\n * A reusable group of fields embedded in a model (a `type Name { … }` block) —\n * e.g. a MongoDB embedded document or a Postgres composite type. Unlike\n * {@link PslModel} it has no storage or identity of its own.\n */\nexport interface PslCompositeType {\n  readonly kind: 'compositeType';\n  readonly name: string;\n  readonly fields: readonly PslField[];\n  readonly attributes: readonly PslAttribute[];\n  readonly span: PslSpan;\n}\n\nexport interface PslNamedTypeDeclaration {\n  readonly kind: 'namedType';\n  readonly name: string;\n  /**\n   * Parser invariant: exactly one of `baseType` and `typeConstructor` is set.\n   * Expressing this as a discriminated union trips TypeScript narrowing when\n   * the declaration flows through helpers that accept the full union.\n   */\n  readonly baseType?: string;\n  readonly typeConstructor?: PslTypeConstructorCall;\n  readonly attributes: readonly PslAttribute[];\n  readonly span: PslSpan;\n}\n\nexport interface PslTypesBlock {\n  readonly kind: 'types';\n  readonly declarations: readonly PslNamedTypeDeclaration[];\n  readonly span: PslSpan;\n}\n\n/**\n * Name of the synthesised namespace bucket the framework parser uses for\n * top-level declarations that appear outside any `namespace { … }` block.\n * The double-underscore decoration signals that the identifier is parser-\n * synthesised and never appears in user-authored PSL source — writing\n * `namespace __unspecified__ { … }` is a parse error.\n *\n * Distinct from the IR sentinel `__unbound__`: the PSL bucket describes\n * syntactic absence at the parser layer; the IR sentinel describes a late-\n * bound storage slot at the IR layer. Per-target interpreters decide how\n * (or whether) to map the PSL bucket to the IR sentinel.\n */\nexport const UNSPECIFIED_PSL_NAMESPACE_ID = '__unspecified__';\n\n/** A value in {@link PslNamespace.entries}: a built-in entity node or an extension-contributed {@link PslExtensionBlock}. */\nexport type PslNamespaceEntry = PslModel | PslEnum | PslCompositeType | PslExtensionBlock;\n\n/**\n * A namespace block, or the parser's synthesised `__unspecified__` bucket for\n * declarations outside any `namespace { … }`. Same-name blocks reopen-merge;\n * `span` points at the first opening.\n *\n * Entities are stored canonically (ADR 224) in `entries[kind][name]`, where\n * `kind` is the PSL keyword for built-ins or the block discriminator for\n * extension kinds, e.g. `entries['policy_select']['ReadPosts']`.\n */\nexport interface PslNamespace {\n  readonly kind: 'namespace';\n  readonly name: string;\n  /** Canonical store: a frozen container of frozen per-kind maps. The accessors below derive from it. */\n  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n  /** Built-in models, from `entries['model']`. Extension kinds: {@link namespacePslExtensionBlocks}. */\n  readonly models: readonly PslModel[];\n  /** Built-in enums, from `entries['enum']`. */\n  readonly enums: readonly PslEnum[];\n  /** Built-in composite types, from `entries['compositeType']`. */\n  readonly compositeTypes: readonly PslCompositeType[];\n  readonly span: PslSpan;\n}\n\n/**\n * Stores `entries`; exposes `models`/`enums`/`compositeTypes` as getters over\n * it. The getters are prototype members (non-enumerable), so spreading or\n * `JSON.stringify`-ing a namespace copies only `entries`, never a duplicate view.\n */\nclass PslNamespaceNode implements PslNamespace {\n  readonly kind = 'namespace' as const;\n  readonly name: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n  readonly span: PslSpan;\n\n  constructor(init: {\n    readonly name: string;\n    readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n    readonly span: PslSpan;\n  }) {\n    this.name = init.name;\n    this.entries = init.entries;\n    this.span = init.span;\n    Object.freeze(this);\n  }\n\n  get models(): readonly PslModel[] {\n    return blindCast<readonly PslModel[], 'entries[model] holds only PslModel by construction'>(\n      Object.values(this.entries['model'] ?? {}),\n    );\n  }\n\n  get enums(): readonly PslEnum[] {\n    return blindCast<readonly PslEnum[], 'entries[enum] holds only PslEnum by construction'>(\n      Object.values(this.entries['enum'] ?? {}),\n    );\n  }\n\n  get compositeTypes(): readonly PslCompositeType[] {\n    return blindCast<\n      readonly PslCompositeType[],\n      'entries[compositeType] holds only PslCompositeType by construction'\n    >(Object.values(this.entries['compositeType'] ?? {}));\n  }\n}\n\n/** Constructs a {@link PslNamespace}. Use this, never a namespace literal — the accessors must derive from `entries`. */\nexport function makePslNamespace(init: {\n  readonly kind: 'namespace';\n  readonly name: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n  readonly span: PslSpan;\n}): PslNamespace {\n  return new PslNamespaceNode(init);\n}\n\n/**\n * Builds the frozen `entries[kind][name]` container from per-kind arrays.\n * Built-ins key on their PSL keyword; extension blocks key on their `kind`\n * discriminator. Call this rather than hand-building the literal.\n */\nexport function makePslNamespaceEntries(\n  models: readonly PslModel[],\n  enums: readonly PslEnum[],\n  compositeTypes: readonly PslCompositeType[],\n  extensionBlocks: readonly PslExtensionBlock[],\n): Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>> {\n  const container: Record<string, Readonly<Record<string, PslNamespaceEntry>>> = {};\n\n  if (models.length > 0) {\n    const map: Record<string, PslModel> = {};\n    for (const m of models) {\n      map[m.name] = m;\n    }\n    container['model'] = Object.freeze(map);\n  }\n\n  if (enums.length > 0) {\n    const map: Record<string, PslEnum> = {};\n    for (const e of enums) {\n      map[e.name] = e;\n    }\n    container['enum'] = Object.freeze(map);\n  }\n\n  if (compositeTypes.length > 0) {\n    const map: Record<string, PslCompositeType> = {};\n    for (const ct of compositeTypes) {\n      map[ct.name] = ct;\n    }\n    container['compositeType'] = Object.freeze(map);\n  }\n\n  for (const block of extensionBlocks) {\n    const existing = container[block.kind];\n    const newMap: Record<string, PslExtensionBlock> = existing\n      ? blindCast<Record<string, PslExtensionBlock>, 'kind map holds only PslExtensionBlock'>({\n          ...existing,\n        })\n      : {};\n    newMap[block.name] = block;\n    container[block.kind] = Object.freeze(newMap);\n  }\n\n  return Object.freeze(container);\n}\n\nexport interface PslDocumentAst {\n  readonly kind: 'document';\n  readonly sourceId: string;\n  readonly namespaces: readonly PslNamespace[];\n  readonly types?: PslTypesBlock;\n  readonly span: PslSpan;\n}\n\n/**\n * Returns all models from every namespace in document order. Convenience\n * for consumers that don't (yet) need namespace-awareness.\n */\nexport function flatPslModels(ast: PslDocumentAst): readonly PslModel[] {\n  return ast.namespaces.flatMap((ns) =>\n    blindCast<PslModel[], 'model kind map contains only PslModel by construction'>(\n      Object.values(ns.entries['model'] ?? {}),\n    ),\n  );\n}\n\n/**\n * Returns all enums from every namespace in document order.\n */\nexport function flatPslEnums(ast: PslDocumentAst): readonly PslEnum[] {\n  return ast.namespaces.flatMap((ns) =>\n    blindCast<PslEnum[], 'enum kind map contains only PslEnum by construction'>(\n      Object.values(ns.entries['enum'] ?? {}),\n    ),\n  );\n}\n\n/**\n * Returns all composite types from every namespace in document order.\n */\nexport function flatPslCompositeTypes(ast: PslDocumentAst): readonly PslCompositeType[] {\n  return ast.namespaces.flatMap((ns) =>\n    blindCast<\n      PslCompositeType[],\n      'compositeType kind map contains only PslCompositeType by construction'\n    >(Object.values(ns.entries['compositeType'] ?? {})),\n  );\n}\n\n/**\n * The set of `entries` kind keys that the framework parser reserves for\n * built-in PSL entity kinds. Any own-enumerable key on `PslNamespace.entries`\n * that is **not** in this set was contributed by an extension-block descriptor.\n *\n * Built-in keys match the PSL keyword used on each block type:\n * `'model'`, `'enum'`, `'compositeType'`.\n */\nexport const BUILTIN_PSL_KIND_KEYS: ReadonlySet<string> = new Set([\n  'model',\n  'enum',\n  'compositeType',\n]);\n\n/**\n * Returns all extension-contributed blocks in the given namespace, in\n * insertion order (the order the parser encountered them in the source).\n *\n * Reads from `namespace.entries`, skipping the three built-in kind keys\n * (`'model'`, `'enum'`, `'compositeType'`). All remaining kind maps contain\n * only `PslExtensionBlock` nodes by construction (see `makePslNamespaceEntries`).\n */\nexport function namespacePslExtensionBlocks(ns: PslNamespace): readonly PslExtensionBlock[] {\n  const result: PslExtensionBlock[] = [];\n  for (const [kindKey, kindMap] of Object.entries(ns.entries)) {\n    if (BUILTIN_PSL_KIND_KEYS.has(kindKey)) continue;\n    for (const entry of Object.values(kindMap)) {\n      result.push(\n        blindCast<\n          PslExtensionBlock,\n          'non-builtin kind maps contain only PslExtensionBlock by construction'\n        >(entry),\n      );\n    }\n  }\n  return result;\n}\n\nexport interface ParsePslDocumentInput {\n  readonly schema: string;\n  readonly sourceId: string;\n  /**\n   * Registry of declarative block descriptors, keyed by arbitrary path\n   * segments with {@link AuthoringPslBlockDescriptor} leaves. The registry\n   * teaches the parser which top-level keywords belong to extension\n   * contributions: when the parser encounters an unknown keyword, it looks\n   * it up here and, when found, reads the block generically into a\n   * {@link PslExtensionBlock} node. Absent or undefined means no extension\n   * blocks are registered and any unknown keyword yields\n   * `PSL_UNSUPPORTED_TOP_LEVEL_BLOCK`.\n   *\n   * Contrast with the parsed block nodes themselves, which live in\n   * {@link PslNamespace.entries} under their discriminator key (read them with\n   * {@link namespacePslExtensionBlocks}); this field holds the registry of\n   * descriptors that teach the parser how to read those blocks.\n   */\n  readonly pslBlockDescriptors?: AuthoringPslBlockDescriptorNamespace;\n  /**\n   * Codec lookup for validating `value`-kind extension block parameters.\n   * When provided alongside `pslBlockDescriptors`, the generic validator runs\n   * over every parsed extension block after the full AST is assembled,\n   * appending any diagnostics to the parse result. Absent or undefined means\n   * no codec validation runs; `ref` resolution still runs when namespace\n   * context is available (built from the assembled namespaces).\n   */\n  readonly codecLookup?: CodecLookup;\n}\n\nexport interface ParsePslDocumentResult {\n  readonly ast: PslDocumentAst;\n  readonly diagnostics: readonly PslDiagnostic[];\n  readonly ok: boolean;\n}\n","/**\n * Generic validator for extension-contributed top-level PSL blocks.\n *\n * One function — {@link validateExtensionBlock} — takes a parsed\n * {@link PslExtensionBlock}, its {@link AuthoringPslBlockDescriptor}, a\n * {@link CodecLookup} (for `value` parameters), and the set of\n * {@link PslNamespace} objects from the document (for `ref` resolution), and\n * returns the full list of {@link PslDiagnostic} objects for the block.\n *\n * Detection logic per failure mode:\n *\n * 1. **Unknown parameter** — keys present in `node.parameters` that are absent\n *    from `descriptor.parameters` (key-set difference). The parser stores\n *    unknown parameters as `kind:'value'` stubs; the validator discovers them\n *    by comparing the key sets, not by inspecting the captured kind.\n *\n * 2. **Missing required parameter** — `descriptor.parameters` entries with\n *    `required: true` whose key is absent from `node.parameters`.\n *\n * 3. **`option` value outside its set** — the captured `token` is not in\n *    `descriptor.values`.\n *\n * 4. **`value` rejected by its codec** — the raw string is first parsed as\n *    JSON (`JSON.parse(raw)`). If `JSON.parse` throws, the literal is not valid\n *    JSON and a `PSL_EXTENSION_INVALID_VALUE` diagnostic is emitted. If parsing\n *    succeeds but `codec.decodeJson(jsonValue)` throws, the JSON value is not\n *    acceptable to the codec and a `PSL_EXTENSION_INVALID_VALUE` diagnostic is\n *    emitted. If `codecLookup.get(codecId)` returns `undefined` (unknown codec\n *    id), a `PSL_EXTENSION_INVALID_VALUE` diagnostic is also emitted.\n *\n * 5. **`ref` that does not resolve within its scope** — the captured\n *    `identifier` is looked up in the PSL document's `PslNamespace` objects\n *    according to `param.scope`:\n *    - `same-namespace`: the referent must be in the same namespace as the\n *      block (the namespace containing the block).\n *    - `same-space`: the referent may be in any namespace in the document.\n *    - `cross-space`: pass-through — enforcement is scoped to first-consumer\n *      need (RLS roles). This case is documented and clearly flagged; the\n *      caller is responsible for wiring cross-space resolution when needed.\n *\n * 6. **`list`** — each element is validated against `param.of` recursively.\n *\n * ### `char`/`varchar` length\n * Not enforced. RLS `using`/`check` strings are unbounded text and the codec\n * already rejects structurally invalid literals; length constraints are a\n * database-side concern, not a PSL authoring constraint.\n *\n * ### `cross-space` scope\n * Implemented as a documented pass-through. The spec permits scoping\n * cross-space enforcement to first-consumer need (RLS roles). When RLS roles\n * arrive, wire `cross-space` resolution through the cross-contract-space\n * coordinate model `(spaceId, namespaceId, entityKind, entityName)`.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { CodecLookup } from '../shared/codec-types';\nimport type { AuthoringPslBlockDescriptor } from '../shared/framework-authoring';\nimport type {\n  PslBlockParam,\n  PslBlockParamRef,\n  PslExtensionBlock,\n  PslExtensionBlockParamValue,\n  PslSpan,\n} from '../shared/psl-extension-block';\nimport type { PslDiagnostic, PslNamespace } from './psl-ast';\n\n/**\n * Context for ref resolution during extension-block validation.\n *\n * - `ownerNamespace` is the `PslNamespace` that contains the block being\n *   validated. Used for `same-namespace` scope checks.\n * - `allNamespaces` is every namespace in the document. Used for `same-space`\n *   scope checks.\n */\nexport interface ExtensionBlockRefResolutionContext {\n  readonly ownerNamespace: PslNamespace;\n  readonly allNamespaces: readonly PslNamespace[];\n}\n\n/**\n * Validate a single parsed extension block against its descriptor.\n *\n * Returns an array of {@link PslDiagnostic} objects (possibly empty). The\n * caller is responsible for threading `sourceId` into each returned diagnostic\n * — the returned objects already have `sourceId` set from the `sourceId`\n * parameter.\n *\n * @param node - The parsed block node produced by the generic framework parser.\n * @param descriptor - The descriptor that claims this block's keyword.\n * @param sourceId - The PSL source file identifier (threaded into diagnostics).\n * @param codecLookup - Used to validate `value`-kind parameter literals via\n *   `codecLookup.get(codecId)?.decodeJson(JSON.parse(raw))`.\n * @param refCtx - Namespace context for `ref`-kind scope resolution. Required\n *   when any descriptor parameter is `kind: 'ref'`; may be omitted if none are.\n */\nexport function validateExtensionBlock(\n  node: PslExtensionBlock,\n  descriptor: AuthoringPslBlockDescriptor,\n  sourceId: string,\n  codecLookup: CodecLookup,\n  refCtx?: ExtensionBlockRefResolutionContext,\n): readonly PslDiagnostic[] {\n  const diagnostics: PslDiagnostic[] = [];\n\n  const descriptorKeys = new Set(Object.keys(descriptor.parameters));\n  const nodeKeys = new Set(Object.keys(node.parameters));\n\n  // 1. Unknown parameters — keys in the node not in the descriptor.\n  for (const key of nodeKeys) {\n    if (!descriptorKeys.has(key)) {\n      const captured = node.parameters[key];\n      diagnostics.push({\n        code: 'PSL_EXTENSION_UNKNOWN_PARAMETER',\n        message: `Unknown parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\". The descriptor does not declare this parameter.`,\n        sourceId,\n        span: captured?.span ?? node.span,\n      });\n    }\n  }\n\n  // 2. Missing required parameters — required descriptor keys absent from the node.\n  for (const [key, param] of Object.entries(descriptor.parameters)) {\n    if (param.required === true && !nodeKeys.has(key)) {\n      diagnostics.push({\n        code: 'PSL_EXTENSION_MISSING_REQUIRED_PARAMETER',\n        message: `Required parameter \"${key}\" is missing from \"${descriptor.keyword}\" block \"${node.name}\".`,\n        sourceId,\n        span: node.span,\n      });\n    }\n  }\n\n  // 3–5. Per-parameter validation for parameters that are present.\n  for (const [key, param] of Object.entries(descriptor.parameters)) {\n    const captured = node.parameters[key];\n    if (captured === undefined) {\n      continue;\n    }\n    validateParam(\n      node,\n      descriptor,\n      key,\n      param,\n      captured,\n      sourceId,\n      codecLookup,\n      refCtx,\n      diagnostics,\n    );\n  }\n\n  return diagnostics;\n}\n\nfunction validateParam(\n  node: PslExtensionBlock,\n  descriptor: AuthoringPslBlockDescriptor,\n  key: string,\n  param: PslBlockParam,\n  captured: PslExtensionBlockParamValue,\n  sourceId: string,\n  codecLookup: CodecLookup,\n  refCtx: ExtensionBlockRefResolutionContext | undefined,\n  diagnostics: PslDiagnostic[],\n): void {\n  switch (param.kind) {\n    case 'option': {\n      if (captured.kind !== 'option') {\n        return;\n      }\n      if (!param.values.includes(captured.token)) {\n        diagnostics.push({\n          code: 'PSL_EXTENSION_OPTION_OUT_OF_SET',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" has value \"${captured.token}\" which is not one of the allowed values: ${param.values.map((v) => `\"${v}\"`).join(', ')}.`,\n          sourceId,\n          span: captured.span,\n        });\n      }\n      return;\n    }\n\n    case 'value': {\n      if (captured.kind !== 'value') {\n        return;\n      }\n      const codec = codecLookup.get(param.codecId);\n      if (codec === undefined) {\n        diagnostics.push({\n          code: 'PSL_EXTENSION_INVALID_VALUE',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" references unknown codec \"${param.codecId}\".`,\n          sourceId,\n          span: captured.span,\n        });\n        return;\n      }\n      let jsonValue: unknown;\n      try {\n        jsonValue = JSON.parse(captured.raw);\n      } catch {\n        diagnostics.push({\n          code: 'PSL_EXTENSION_INVALID_VALUE',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" is not a valid JSON literal (expected a JSON string, number, boolean, or null): ${captured.raw}`,\n          sourceId,\n          span: captured.span,\n        });\n        return;\n      }\n      try {\n        codec.decodeJson(\n          blindCast<JsonValue, 'JSON.parse returns a JsonValue-compatible value'>(jsonValue),\n        );\n      } catch (err) {\n        const reason = err instanceof Error ? err.message : String(err);\n        diagnostics.push({\n          code: 'PSL_EXTENSION_INVALID_VALUE',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" was rejected by codec \"${param.codecId}\": ${reason}`,\n          sourceId,\n          span: captured.span,\n        });\n      }\n      return;\n    }\n\n    case 'ref': {\n      if (captured.kind !== 'ref') {\n        return;\n      }\n      validateRef(\n        node,\n        descriptor,\n        key,\n        param,\n        captured.identifier,\n        captured.span,\n        sourceId,\n        refCtx,\n        diagnostics,\n      );\n      return;\n    }\n\n    case 'list': {\n      if (captured.kind !== 'list') {\n        return;\n      }\n      for (const item of captured.items) {\n        validateParam(\n          node,\n          descriptor,\n          key,\n          param.of,\n          item,\n          sourceId,\n          codecLookup,\n          refCtx,\n          diagnostics,\n        );\n      }\n      return;\n    }\n  }\n}\n\nfunction validateRef(\n  node: PslExtensionBlock,\n  descriptor: AuthoringPslBlockDescriptor,\n  key: string,\n  param: PslBlockParamRef,\n  identifier: string,\n  span: PslSpan,\n  sourceId: string,\n  refCtx: ExtensionBlockRefResolutionContext | undefined,\n  diagnostics: PslDiagnostic[],\n): void {\n  if (param.scope === 'cross-space') {\n    // cross-space enforcement is a documented pass-through. The spec permits\n    // scoping cross-space resolution to first-consumer need (RLS roles). When\n    // that consumer arrives, wire resolution here through the\n    // cross-contract-space coordinate model\n    // (spaceId, namespaceId, entityKind, entityName).\n    // For now, cross-space refs pass validation unconditionally.\n    return;\n  }\n\n  if (refCtx === undefined) {\n    // If no resolution context was provided, skip ref resolution. This matches\n    // the closed-grammar invariant: callers that register ref parameters must\n    // provide resolution context; callers without namespaces (e.g. unit tests\n    // that only exercise other validation modes) can omit it.\n    return;\n  }\n\n  const namespacesToSearch: readonly PslNamespace[] =\n    param.scope === 'same-namespace' ? [refCtx.ownerNamespace] : refCtx.allNamespaces;\n\n  if (!resolveEntityInNamespaces(identifier, param.refKind, namespacesToSearch)) {\n    const scopeLabel =\n      param.scope === 'same-namespace' ? 'the same namespace' : 'any namespace in the schema';\n    diagnostics.push({\n      code: 'PSL_EXTENSION_UNRESOLVED_REF',\n      message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" refers to \"${identifier}\" (expected ${param.refKind}), but no entity with that name and kind was found in ${scopeLabel}.`,\n      sourceId,\n      span,\n    });\n  }\n}\n\n/**\n * True if an entity named `name` of kind `refKind` exists in any of the given\n * namespaces. Built-in and extension kinds resolve the same way, through\n * `entries[refKind]`.\n */\nfunction resolveEntityInNamespaces(\n  name: string,\n  refKind: string,\n  namespaces: readonly PslNamespace[],\n): boolean {\n  for (const ns of namespaces) {\n    const kindMap = ns.entries[refKind];\n    if (kindMap !== undefined && Object.hasOwn(kindMap, name)) return true;\n  }\n  return false;\n}\n"],"mappings":"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"}
+{"version":3,"file":"psl-ast.mjs","names":[],"sources":["../src/control/psl-ast.ts","../src/control/psl-extension-block-validator.ts"],"sourcesContent":["export type { AuthoringPslBlockDescriptorNamespace } from '../shared/framework-authoring';\nexport type {\n  PslBlockParam,\n  PslBlockParamList,\n  PslBlockParamOption,\n  PslBlockParamRef,\n  PslBlockParamValue,\n  PslDiagnosticCode,\n  PslExtensionBlock,\n  PslExtensionBlockAttribute,\n  PslExtensionBlockAttributeArg,\n  PslExtensionBlockParamBare,\n  PslExtensionBlockParamList,\n  PslExtensionBlockParamOption,\n  PslExtensionBlockParamRef,\n  PslExtensionBlockParamScalarValue,\n  PslExtensionBlockParamValue,\n  PslPosition,\n  PslSpan,\n} from '../shared/psl-extension-block';\n\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { CodecLookup } from '../shared/codec-types';\nimport type { AuthoringPslBlockDescriptorNamespace } from '../shared/framework-authoring';\nimport type { PslDiagnosticCode, PslExtensionBlock, PslSpan } from '../shared/psl-extension-block';\n\nexport interface PslDiagnostic {\n  readonly code: PslDiagnosticCode;\n  readonly message: string;\n  readonly sourceId: string;\n  readonly span: PslSpan;\n}\n\nexport interface PslDefaultFunctionValue {\n  readonly kind: 'function';\n  readonly name: 'autoincrement' | 'now';\n}\n\nexport interface PslDefaultLiteralValue {\n  readonly kind: 'literal';\n  readonly value: string | number | boolean;\n}\n\nexport type PslDefaultValue = PslDefaultFunctionValue | PslDefaultLiteralValue;\n\nexport type PslAttributeTarget = 'field' | 'model' | 'enum' | 'namedType';\n\nexport interface PslAttributePositionalArgument {\n  readonly kind: 'positional';\n  readonly value: string;\n  readonly span: PslSpan;\n}\n\nexport interface PslAttributeNamedArgument {\n  readonly kind: 'named';\n  readonly name: string;\n  readonly value: string;\n  readonly span: PslSpan;\n}\n\nexport type PslAttributeArgument = PslAttributePositionalArgument | PslAttributeNamedArgument;\n\nexport interface PslTypeConstructorCall {\n  readonly kind: 'typeConstructor';\n  readonly path: readonly string[];\n  readonly args: readonly PslAttributeArgument[];\n  readonly span: PslSpan;\n}\n\nexport interface PslAttribute {\n  readonly kind: 'attribute';\n  readonly target: PslAttributeTarget;\n  readonly name: string;\n  readonly args: readonly PslAttributeArgument[];\n  readonly span: PslSpan;\n}\n\nexport type PslReferentialAction = string;\n\nexport type PslFieldAttribute = PslAttribute;\n\nexport interface PslField {\n  readonly kind: 'field';\n  readonly name: string;\n  /** Unqualified type name, e.g. `\"User\"` for both `User`, `auth.User`, and `supabase:auth.User`. */\n  readonly typeName: string;\n  /** Namespace qualifier from a dot-qualified type reference, e.g. `\"auth\"` for `auth.User` or `supabase:auth.User`. Absent for unqualified types. */\n  readonly typeNamespaceId?: string;\n  /**\n   * Contract-space qualifier from a colon-prefix type reference, e.g. `\"supabase\"` for\n   * `supabase:auth.User` or `supabase:User`. Absent for local (same-space) type references.\n   *\n   * When present, the field references a model from a different contract space. The namespace\n   * (`typeNamespaceId`) and model name (`typeName`) identify the target within that space.\n   * Physical table resolution against the extension contract is deferred to the aggregate stage (M3).\n   */\n  readonly typeContractSpaceId?: string;\n  readonly typeConstructor?: PslTypeConstructorCall;\n  readonly optional: boolean;\n  readonly list: boolean;\n  readonly typeRef?: string;\n  readonly attributes: readonly PslFieldAttribute[];\n  readonly span: PslSpan;\n}\n\nexport interface PslUniqueConstraint {\n  readonly kind: 'unique';\n  readonly fields: readonly string[];\n  readonly span: PslSpan;\n}\n\nexport interface PslIndexConstraint {\n  readonly kind: 'index';\n  readonly fields: readonly string[];\n  readonly span: PslSpan;\n}\n\nexport type PslModelAttribute = PslAttribute;\n\nexport interface PslModel {\n  readonly kind: 'model';\n  readonly name: string;\n  readonly fields: readonly PslField[];\n  readonly attributes: readonly PslModelAttribute[];\n  readonly span: PslSpan;\n  /**\n   * Optional leading comment line emitted above the `model` keyword by the\n   * printer. Producers (e.g. `sqlSchemaIrToPslAst`) attach introspection\n   * advisories such as \"// WARNING: This table has no primary key in the\n   * database\" here. The parser leaves this field unset; round-tripping a\n   * parsed schema does not re-attach comments.\n   */\n  readonly comment?: string;\n}\n\nexport interface PslEnumValue {\n  readonly kind: 'enumValue';\n  readonly name: string;\n  /**\n   * Optional storage label for the enum member, captured from a trailing\n   * `@map(\"...\")` attribute on the member line. The parser populates this\n   * when the source PSL carries an explicit `@map`. Producers (e.g.\n   * `sqlSchemaIrToPslAst`) leave it unset; the printer emits `@map(...)`\n   * automatically when normalisation would change the printed member name\n   * (so an enum value `'in-progress'` becomes `inProgress @map(\"in-progress\")`\n   * in PSL, preserving the round-trip).\n   */\n  readonly mapName?: string;\n  readonly span: PslSpan;\n}\n\nexport interface PslEnum {\n  readonly kind: 'enum';\n  readonly name: string;\n  readonly values: readonly PslEnumValue[];\n  readonly attributes: readonly PslAttribute[];\n  readonly span: PslSpan;\n}\n\n/**\n * A reusable group of fields embedded in a model (a `type Name { … }` block) —\n * e.g. a MongoDB embedded document or a Postgres composite type. Unlike\n * {@link PslModel} it has no storage or identity of its own.\n */\nexport interface PslCompositeType {\n  readonly kind: 'compositeType';\n  readonly name: string;\n  readonly fields: readonly PslField[];\n  readonly attributes: readonly PslAttribute[];\n  readonly span: PslSpan;\n}\n\nexport interface PslNamedTypeDeclaration {\n  readonly kind: 'namedType';\n  readonly name: string;\n  /**\n   * Parser invariant: exactly one of `baseType` and `typeConstructor` is set.\n   * Expressing this as a discriminated union trips TypeScript narrowing when\n   * the declaration flows through helpers that accept the full union.\n   */\n  readonly baseType?: string;\n  readonly typeConstructor?: PslTypeConstructorCall;\n  readonly attributes: readonly PslAttribute[];\n  readonly span: PslSpan;\n}\n\nexport interface PslTypesBlock {\n  readonly kind: 'types';\n  readonly declarations: readonly PslNamedTypeDeclaration[];\n  readonly span: PslSpan;\n}\n\n/**\n * Name of the synthesised namespace bucket the framework parser uses for\n * top-level declarations that appear outside any `namespace { … }` block.\n * The double-underscore decoration signals that the identifier is parser-\n * synthesised and never appears in user-authored PSL source — writing\n * `namespace __unspecified__ { … }` is a parse error.\n *\n * Distinct from the IR sentinel `__unbound__`: the PSL bucket describes\n * syntactic absence at the parser layer; the IR sentinel describes a late-\n * bound storage slot at the IR layer. Per-target interpreters decide how\n * (or whether) to map the PSL bucket to the IR sentinel.\n */\nexport const UNSPECIFIED_PSL_NAMESPACE_ID = '__unspecified__';\n\n/** A value in {@link PslNamespace.entries}: a built-in entity node or an extension-contributed {@link PslExtensionBlock}. */\nexport type PslNamespaceEntry = PslModel | PslEnum | PslCompositeType | PslExtensionBlock;\n\n/**\n * A namespace block, or the parser's synthesised `__unspecified__` bucket for\n * declarations outside any `namespace { … }`. Same-name blocks reopen-merge;\n * `span` points at the first opening.\n *\n * Entities are stored canonically (ADR 224) in `entries[kind][name]`, where\n * `kind` is the PSL keyword for built-ins or the block discriminator for\n * extension kinds, e.g. `entries['policy_select']['ReadPosts']`.\n */\nexport interface PslNamespace {\n  readonly kind: 'namespace';\n  readonly name: string;\n  /** Canonical store: a frozen container of frozen per-kind maps. The accessors below derive from it. */\n  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n  /** Built-in models, from `entries['model']`. Extension kinds: {@link namespacePslExtensionBlocks}. */\n  readonly models: readonly PslModel[];\n  /** Built-in enums, from `entries['enum']`. */\n  readonly enums: readonly PslEnum[];\n  /** Built-in composite types, from `entries['compositeType']`. */\n  readonly compositeTypes: readonly PslCompositeType[];\n  readonly span: PslSpan;\n}\n\n/**\n * Stores `entries`; exposes `models`/`enums`/`compositeTypes` as getters over\n * it. The getters are prototype members (non-enumerable), so spreading or\n * `JSON.stringify`-ing a namespace copies only `entries`, never a duplicate view.\n */\nclass PslNamespaceNode implements PslNamespace {\n  readonly kind = 'namespace' as const;\n  readonly name: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n  readonly span: PslSpan;\n\n  constructor(init: {\n    readonly name: string;\n    readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n    readonly span: PslSpan;\n  }) {\n    this.name = init.name;\n    this.entries = init.entries;\n    this.span = init.span;\n    Object.freeze(this);\n  }\n\n  get models(): readonly PslModel[] {\n    return blindCast<readonly PslModel[], 'entries[model] holds only PslModel by construction'>(\n      Object.values(this.entries['model'] ?? {}),\n    );\n  }\n\n  get enums(): readonly PslEnum[] {\n    return blindCast<readonly PslEnum[], 'entries[enum] holds only PslEnum by construction'>(\n      Object.values(this.entries['enum'] ?? {}),\n    );\n  }\n\n  get compositeTypes(): readonly PslCompositeType[] {\n    return blindCast<\n      readonly PslCompositeType[],\n      'entries[compositeType] holds only PslCompositeType by construction'\n    >(Object.values(this.entries['compositeType'] ?? {}));\n  }\n}\n\n/** Constructs a {@link PslNamespace}. Use this, never a namespace literal — the accessors must derive from `entries`. */\nexport function makePslNamespace(init: {\n  readonly kind: 'namespace';\n  readonly name: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;\n  readonly span: PslSpan;\n}): PslNamespace {\n  return new PslNamespaceNode(init);\n}\n\n/**\n * Builds the frozen `entries[kind][name]` container from per-kind arrays.\n * Built-ins key on their PSL keyword; extension blocks key on their `kind`\n * discriminator. Call this rather than hand-building the literal.\n */\nexport function makePslNamespaceEntries(\n  models: readonly PslModel[],\n  enums: readonly PslEnum[],\n  compositeTypes: readonly PslCompositeType[],\n  extensionBlocks: readonly PslExtensionBlock[],\n): Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>> {\n  const container: Record<string, Readonly<Record<string, PslNamespaceEntry>>> = {};\n\n  if (models.length > 0) {\n    const map: Record<string, PslModel> = {};\n    for (const m of models) {\n      map[m.name] = m;\n    }\n    container['model'] = Object.freeze(map);\n  }\n\n  if (enums.length > 0) {\n    const map: Record<string, PslEnum> = {};\n    for (const e of enums) {\n      map[e.name] = e;\n    }\n    container['enum'] = Object.freeze(map);\n  }\n\n  if (compositeTypes.length > 0) {\n    const map: Record<string, PslCompositeType> = {};\n    for (const ct of compositeTypes) {\n      map[ct.name] = ct;\n    }\n    container['compositeType'] = Object.freeze(map);\n  }\n\n  for (const block of extensionBlocks) {\n    const existing = container[block.kind];\n    const newMap: Record<string, PslExtensionBlock> = existing\n      ? blindCast<Record<string, PslExtensionBlock>, 'kind map holds only PslExtensionBlock'>({\n          ...existing,\n        })\n      : {};\n    newMap[block.name] = block;\n    container[block.kind] = Object.freeze(newMap);\n  }\n\n  return Object.freeze(container);\n}\n\nexport interface PslDocumentAst {\n  readonly kind: 'document';\n  readonly sourceId: string;\n  readonly namespaces: readonly PslNamespace[];\n  readonly types?: PslTypesBlock;\n  readonly span: PslSpan;\n}\n\n/**\n * Returns all models from every namespace in document order. Convenience\n * for consumers that don't (yet) need namespace-awareness.\n */\nexport function flatPslModels(ast: PslDocumentAst): readonly PslModel[] {\n  return ast.namespaces.flatMap((ns) =>\n    blindCast<PslModel[], 'model kind map contains only PslModel by construction'>(\n      Object.values(ns.entries['model'] ?? {}),\n    ),\n  );\n}\n\n/**\n * Returns all enums from every namespace in document order.\n */\nexport function flatPslEnums(ast: PslDocumentAst): readonly PslEnum[] {\n  return ast.namespaces.flatMap((ns) =>\n    blindCast<PslEnum[], 'enum kind map contains only PslEnum by construction'>(\n      Object.values(ns.entries['enum'] ?? {}),\n    ),\n  );\n}\n\n/**\n * Returns all composite types from every namespace in document order.\n */\nexport function flatPslCompositeTypes(ast: PslDocumentAst): readonly PslCompositeType[] {\n  return ast.namespaces.flatMap((ns) =>\n    blindCast<\n      PslCompositeType[],\n      'compositeType kind map contains only PslCompositeType by construction'\n    >(Object.values(ns.entries['compositeType'] ?? {})),\n  );\n}\n\n/**\n * The set of `entries` kind keys that the framework parser reserves for\n * built-in PSL entity kinds. Any own-enumerable key on `PslNamespace.entries`\n * that is **not** in this set was contributed by an extension-block descriptor.\n *\n * Built-in keys match the PSL keyword used on each block type:\n * `'model'`, `'enum'`, `'compositeType'`.\n */\nexport const BUILTIN_PSL_KIND_KEYS: ReadonlySet<string> = new Set([\n  'model',\n  'enum',\n  'compositeType',\n]);\n\n/**\n * Returns all extension-contributed blocks in the given namespace, in\n * insertion order (the order the parser encountered them in the source).\n *\n * Reads from `namespace.entries`, skipping the built-in kind keys\n * (`'model'`, `'enum'`, `'compositeType'`). All remaining kind maps contain\n * only `PslExtensionBlock` nodes by construction (see `makePslNamespaceEntries`).\n */\nexport function namespacePslExtensionBlocks(ns: PslNamespace): readonly PslExtensionBlock[] {\n  const result: PslExtensionBlock[] = [];\n  for (const [kindKey, kindMap] of Object.entries(ns.entries)) {\n    if (BUILTIN_PSL_KIND_KEYS.has(kindKey)) continue;\n    for (const entry of Object.values(kindMap)) {\n      result.push(\n        blindCast<\n          PslExtensionBlock,\n          'non-builtin kind maps contain only PslExtensionBlock by construction'\n        >(entry),\n      );\n    }\n  }\n  return result;\n}\n\nexport interface ParsePslDocumentInput {\n  readonly schema: string;\n  readonly sourceId: string;\n  /**\n   * Registry of declarative block descriptors, keyed by arbitrary path\n   * segments with {@link AuthoringPslBlockDescriptor} leaves. The registry\n   * teaches the parser which top-level keywords belong to extension\n   * contributions: when the parser encounters an unknown keyword, it looks\n   * it up here and, when found, reads the block generically into a\n   * {@link PslExtensionBlock} node. Absent or undefined means no extension\n   * blocks are registered and any unknown keyword yields\n   * `PSL_UNSUPPORTED_TOP_LEVEL_BLOCK`.\n   *\n   * Contrast with the parsed block nodes themselves, which live in\n   * {@link PslNamespace.entries} under their discriminator key (read them with\n   * {@link namespacePslExtensionBlocks}); this field holds the registry of\n   * descriptors that teach the parser how to read those blocks.\n   */\n  readonly pslBlockDescriptors?: AuthoringPslBlockDescriptorNamespace;\n  /**\n   * Codec lookup for validating `value`-kind extension block parameters.\n   * When provided alongside `pslBlockDescriptors`, the generic validator runs\n   * over every parsed extension block after the full AST is assembled,\n   * appending any diagnostics to the parse result. Absent or undefined means\n   * no codec validation runs; `ref` resolution still runs when namespace\n   * context is available (built from the assembled namespaces).\n   */\n  readonly codecLookup?: CodecLookup;\n}\n\nexport interface ParsePslDocumentResult {\n  readonly ast: PslDocumentAst;\n  readonly diagnostics: readonly PslDiagnostic[];\n  readonly ok: boolean;\n}\n","/**\n * Generic validator for extension-contributed top-level PSL blocks.\n *\n * One function — {@link validateExtensionBlock} — takes a parsed\n * {@link PslExtensionBlock}, its {@link AuthoringPslBlockDescriptor}, a\n * {@link CodecLookup} (for `value` parameters), and the set of\n * {@link PslNamespace} objects from the document (for `ref` resolution), and\n * returns the full list of {@link PslDiagnostic} objects for the block.\n *\n * Detection logic per failure mode:\n *\n * 1. **Unknown parameter** — keys present in `node.parameters` that are absent\n *    from `descriptor.parameters` (key-set difference). The parser stores\n *    unknown parameters as `kind:'value'` stubs; the validator discovers them\n *    by comparing the key sets, not by inspecting the captured kind.\n *\n * 2. **Missing required parameter** — `descriptor.parameters` entries with\n *    `required: true` whose key is absent from `node.parameters`.\n *\n * 3. **`option` value outside its set** — the captured `token` is not in\n *    `descriptor.values`.\n *\n * 4. **`value` rejected by its codec** — the raw string is first parsed as\n *    JSON (`JSON.parse(raw)`). If `JSON.parse` throws, the literal is not valid\n *    JSON and a `PSL_EXTENSION_INVALID_VALUE` diagnostic is emitted. If parsing\n *    succeeds but `codec.decodeJson(jsonValue)` throws, the JSON value is not\n *    acceptable to the codec and a `PSL_EXTENSION_INVALID_VALUE` diagnostic is\n *    emitted. If `codecLookup.get(codecId)` returns `undefined` (unknown codec\n *    id), a `PSL_EXTENSION_INVALID_VALUE` diagnostic is also emitted.\n *\n * 5. **`ref` that does not resolve within its scope** — the captured\n *    `identifier` is looked up in the PSL document's `PslNamespace` objects\n *    according to `param.scope`:\n *    - `same-namespace`: the referent must be in the same namespace as the\n *      block (the namespace containing the block).\n *    - `same-space`: the referent may be in any namespace in the document.\n *    - `cross-space`: pass-through — enforcement is scoped to first-consumer\n *      need (RLS roles). This case is documented and clearly flagged; the\n *      caller is responsible for wiring cross-space resolution when needed.\n *\n * 6. **`list`** — each element is validated against `param.of` recursively.\n *\n * ### `char`/`varchar` length\n * Not enforced. RLS `using`/`check` strings are unbounded text and the codec\n * already rejects structurally invalid literals; length constraints are a\n * database-side concern, not a PSL authoring constraint.\n *\n * ### `cross-space` scope\n * Implemented as a documented pass-through. The spec permits scoping\n * cross-space enforcement to first-consumer need (RLS roles). When RLS roles\n * arrive, wire `cross-space` resolution through the cross-contract-space\n * coordinate model `(spaceId, namespaceId, entityKind, entityName)`.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { CodecLookup } from '../shared/codec-types';\nimport type { AuthoringPslBlockDescriptor } from '../shared/framework-authoring';\nimport type {\n  PslBlockParam,\n  PslBlockParamRef,\n  PslExtensionBlock,\n  PslExtensionBlockParamValue,\n  PslSpan,\n} from '../shared/psl-extension-block';\nimport type { PslDiagnostic, PslNamespace } from './psl-ast';\n\n/**\n * Context for ref resolution during extension-block validation.\n *\n * - `ownerNamespace` is the `PslNamespace` that contains the block being\n *   validated. Used for `same-namespace` scope checks.\n * - `allNamespaces` is every namespace in the document. Used for `same-space`\n *   scope checks.\n */\nexport interface ExtensionBlockRefResolutionContext {\n  readonly ownerNamespace: PslNamespace;\n  readonly allNamespaces: readonly PslNamespace[];\n}\n\n/**\n * Validate a single parsed extension block against its descriptor.\n *\n * Returns an array of {@link PslDiagnostic} objects (possibly empty). The\n * caller is responsible for threading `sourceId` into each returned diagnostic\n * — the returned objects already have `sourceId` set from the `sourceId`\n * parameter.\n *\n * @param node - The parsed block node produced by the generic framework parser.\n * @param descriptor - The descriptor that claims this block's keyword.\n * @param sourceId - The PSL source file identifier (threaded into diagnostics).\n * @param codecLookup - Used to validate `value`-kind parameter literals via\n *   `codecLookup.get(codecId)?.decodeJson(JSON.parse(raw))`.\n * @param refCtx - Namespace context for `ref`-kind scope resolution. Required\n *   when any descriptor parameter is `kind: 'ref'`; may be omitted if none are.\n */\nexport function validateExtensionBlock(\n  node: PslExtensionBlock,\n  descriptor: AuthoringPslBlockDescriptor,\n  sourceId: string,\n  codecLookup: CodecLookup,\n  refCtx?: ExtensionBlockRefResolutionContext,\n): readonly PslDiagnostic[] {\n  const diagnostics: PslDiagnostic[] = [];\n\n  const descriptorKeys = new Set(Object.keys(descriptor.parameters));\n  const nodeKeys = new Set(Object.keys(node.parameters));\n\n  // 1. Unknown parameters — keys in the node not in the descriptor.\n  if (!descriptor.variadicParameters) {\n    for (const key of nodeKeys) {\n      if (!descriptorKeys.has(key)) {\n        const captured = node.parameters[key];\n        diagnostics.push({\n          code: 'PSL_EXTENSION_UNKNOWN_PARAMETER',\n          message: `Unknown parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\". The descriptor does not declare this parameter.`,\n          sourceId,\n          span: captured?.span ?? node.span,\n        });\n      }\n    }\n  }\n\n  // 2. Missing required parameters — required descriptor keys absent from the node.\n  for (const [key, param] of Object.entries(descriptor.parameters)) {\n    if (param.required === true && !nodeKeys.has(key)) {\n      diagnostics.push({\n        code: 'PSL_EXTENSION_MISSING_REQUIRED_PARAMETER',\n        message: `Required parameter \"${key}\" is missing from \"${descriptor.keyword}\" block \"${node.name}\".`,\n        sourceId,\n        span: node.span,\n      });\n    }\n  }\n\n  // 3–5. Per-parameter validation for parameters that are present.\n  for (const [key, param] of Object.entries(descriptor.parameters)) {\n    const captured = node.parameters[key];\n    if (captured === undefined) {\n      continue;\n    }\n    validateParam(\n      node,\n      descriptor,\n      key,\n      param,\n      captured,\n      sourceId,\n      codecLookup,\n      refCtx,\n      diagnostics,\n    );\n  }\n\n  return diagnostics;\n}\n\nfunction validateParam(\n  node: PslExtensionBlock,\n  descriptor: AuthoringPslBlockDescriptor,\n  key: string,\n  param: PslBlockParam,\n  captured: PslExtensionBlockParamValue,\n  sourceId: string,\n  codecLookup: CodecLookup,\n  refCtx: ExtensionBlockRefResolutionContext | undefined,\n  diagnostics: PslDiagnostic[],\n): void {\n  switch (param.kind) {\n    case 'option': {\n      if (captured.kind !== 'option') {\n        return;\n      }\n      if (!param.values.includes(captured.token)) {\n        diagnostics.push({\n          code: 'PSL_EXTENSION_OPTION_OUT_OF_SET',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" has value \"${captured.token}\" which is not one of the allowed values: ${param.values.map((v) => `\"${v}\"`).join(', ')}.`,\n          sourceId,\n          span: captured.span,\n        });\n      }\n      return;\n    }\n\n    case 'value': {\n      if (captured.kind !== 'value') {\n        return;\n      }\n      const codec = codecLookup.get(param.codecId);\n      if (codec === undefined) {\n        diagnostics.push({\n          code: 'PSL_EXTENSION_INVALID_VALUE',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" references unknown codec \"${param.codecId}\".`,\n          sourceId,\n          span: captured.span,\n        });\n        return;\n      }\n      let jsonValue: unknown;\n      try {\n        jsonValue = JSON.parse(captured.raw);\n      } catch {\n        diagnostics.push({\n          code: 'PSL_EXTENSION_INVALID_VALUE',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" is not a valid JSON literal (expected a JSON string, number, boolean, or null): ${captured.raw}`,\n          sourceId,\n          span: captured.span,\n        });\n        return;\n      }\n      try {\n        codec.decodeJson(\n          blindCast<JsonValue, 'JSON.parse returns a JsonValue-compatible value'>(jsonValue),\n        );\n      } catch (err) {\n        const reason = err instanceof Error ? err.message : String(err);\n        diagnostics.push({\n          code: 'PSL_EXTENSION_INVALID_VALUE',\n          message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" was rejected by codec \"${param.codecId}\": ${reason}`,\n          sourceId,\n          span: captured.span,\n        });\n      }\n      return;\n    }\n\n    case 'ref': {\n      if (captured.kind !== 'ref') {\n        return;\n      }\n      validateRef(\n        node,\n        descriptor,\n        key,\n        param,\n        captured.identifier,\n        captured.span,\n        sourceId,\n        refCtx,\n        diagnostics,\n      );\n      return;\n    }\n\n    case 'list': {\n      if (captured.kind !== 'list') {\n        return;\n      }\n      for (const item of captured.items) {\n        validateParam(\n          node,\n          descriptor,\n          key,\n          param.of,\n          item,\n          sourceId,\n          codecLookup,\n          refCtx,\n          diagnostics,\n        );\n      }\n      return;\n    }\n  }\n}\n\nfunction validateRef(\n  node: PslExtensionBlock,\n  descriptor: AuthoringPslBlockDescriptor,\n  key: string,\n  param: PslBlockParamRef,\n  identifier: string,\n  span: PslSpan,\n  sourceId: string,\n  refCtx: ExtensionBlockRefResolutionContext | undefined,\n  diagnostics: PslDiagnostic[],\n): void {\n  if (param.scope === 'cross-space') {\n    // cross-space enforcement is a documented pass-through. The spec permits\n    // scoping cross-space resolution to first-consumer need (RLS roles). When\n    // that consumer arrives, wire resolution here through the\n    // cross-contract-space coordinate model\n    // (spaceId, namespaceId, entityKind, entityName).\n    // For now, cross-space refs pass validation unconditionally.\n    return;\n  }\n\n  if (refCtx === undefined) {\n    // If no resolution context was provided, skip ref resolution. This matches\n    // the closed-grammar invariant: callers that register ref parameters must\n    // provide resolution context; callers without namespaces (e.g. unit tests\n    // that only exercise other validation modes) can omit it.\n    return;\n  }\n\n  const namespacesToSearch: readonly PslNamespace[] =\n    param.scope === 'same-namespace' ? [refCtx.ownerNamespace] : refCtx.allNamespaces;\n\n  if (!resolveEntityInNamespaces(identifier, param.refKind, namespacesToSearch)) {\n    const scopeLabel =\n      param.scope === 'same-namespace' ? 'the same namespace' : 'any namespace in the schema';\n    diagnostics.push({\n      code: 'PSL_EXTENSION_UNRESOLVED_REF',\n      message: `Parameter \"${key}\" in \"${descriptor.keyword}\" block \"${node.name}\" refers to \"${identifier}\" (expected ${param.refKind}), but no entity with that name and kind was found in ${scopeLabel}.`,\n      sourceId,\n      span,\n    });\n  }\n}\n\n/**\n * True if an entity named `name` of kind `refKind` exists in any of the given\n * namespaces. Built-in and extension kinds resolve the same way, through\n * `entries[refKind]`.\n */\nfunction resolveEntityInNamespaces(\n  name: string,\n  refKind: string,\n  namespaces: readonly PslNamespace[],\n): boolean {\n  for (const ns of namespaces) {\n    const kindMap = ns.entries[refKind];\n    if (kindMap !== undefined && Object.hasOwn(kindMap, name)) return true;\n  }\n  return false;\n}\n"],"mappings":"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"}

package/dist/runtime.d.mts

@@ -1,4 +1,4 @@
-import { o as CodecCallContext } from "./codec-DCQAerzB.mjs";
+import { t as CodecCallContext } from "./codec-types-7Qng7VFc.mjs";
 import { PlanMeta } from "@prisma-next/contract/types";
 
 //#region src/annotations.d.ts

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@prisma-next/framework-components",
-  "version": "0.13.0-dev.2",
+  "version": "0.13.0-dev.20",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Framework component types, assembly logic, and stack creation for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.13.0-dev.2",
-    "@prisma-next/operations": "0.13.0-dev.2",
-    "@prisma-next/ts-render": "0.13.0-dev.2",
-    "@prisma-next/utils": "0.13.0-dev.2",
+    "@prisma-next/contract": "0.13.0-dev.20",
+    "@prisma-next/operations": "0.13.0-dev.20",
+    "@prisma-next/ts-render": "0.13.0-dev.20",
+    "@prisma-next/utils": "0.13.0-dev.20",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0"
   },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.13.0-dev.2",
-    "@prisma-next/tsdown": "0.13.0-dev.2",
+    "@prisma-next/tsconfig": "0.13.0-dev.20",
+    "@prisma-next/tsdown": "0.13.0-dev.20",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/control/control-migration-types.ts

@@ -75,24 +75,6 @@ export interface MigrationMetadata {
  */
 export type MigrationOperationClass = 'additive' | 'widening' | 'destructive' | 'data';
 
-// ============================================================================
-// Serialized Query Plan
-// ============================================================================
-
-/**
- * A lowered query statement as stored in ops.json.
- * Contains the SQL string and parameter values — ready for execution.
- * Lowering from query builder AST to SQL happens at verify time.
- *
- * The Postgres `dataTransform` factory uses this shape internally to
- * carry the user's lowered `check`/`run` plans before wrapping them
- * into precheck/execute/postcheck steps on the unified migration op.
- */
-export interface SerializedQueryPlan {
-  readonly sql: string;
-  readonly params: readonly unknown[];
-}
-
 /**
  * Policy defining which operation classes are allowed during a migration.
  */
@@ -185,9 +167,10 @@ export interface OpFactoryCall {
    * Lower this call to a runtime migration plan operation suitable for
    * execution / inclusion in `ops.json`. Concrete implementations narrow
    * the return type via covariant return (e.g. SQL targets return
-   * `SqlMigrationPlanOperation<TTargetDetails>`).
+   * `SqlMigrationPlanOperation<TTargetDetails>`). May return a Promise when
+   * the lowering requires async codec resolution (e.g. DDL with literal defaults).
    */
-  toOp(): MigrationPlanOperation;
+  toOp(): MigrationPlanOperation | Promise<MigrationPlanOperation>;
 }
 
 // ============================================================================
@@ -223,8 +206,8 @@ export interface MigrationPlan {
     readonly storageHash: string;
     readonly profileHash?: string;
   };
-  /** Ordered list of operations to execute. */
-  readonly operations: readonly MigrationPlanOperation[];
+  /** Ordered list of operations to execute. May contain Promises for ops that require async codec resolution. */
+  readonly operations: readonly (MigrationPlanOperation | Promise<MigrationPlanOperation>)[];
   /**
    * Sorted, deduplicated invariant ids declared by this plan's data-transform
    * ops. Authored migrations carry the canonical value from

package/src/control/psl-ast.ts

@@ -7,6 +7,9 @@ export type {
   PslBlockParamValue,
   PslDiagnosticCode,
   PslExtensionBlock,
+  PslExtensionBlockAttribute,
+  PslExtensionBlockAttributeArg,
+  PslExtensionBlockParamBare,
   PslExtensionBlockParamList,
   PslExtensionBlockParamOption,
   PslExtensionBlockParamRef,
@@ -391,7 +394,7 @@ export const BUILTIN_PSL_KIND_KEYS: ReadonlySet<string> = new Set([
  * Returns all extension-contributed blocks in the given namespace, in
  * insertion order (the order the parser encountered them in the source).
  *
- * Reads from `namespace.entries`, skipping the three built-in kind keys
+ * Reads from `namespace.entries`, skipping the built-in kind keys
  * (`'model'`, `'enum'`, `'compositeType'`). All remaining kind maps contain
  * only `PslExtensionBlock` nodes by construction (see `makePslNamespaceEntries`).
  */

package/src/control/psl-extension-block-validator.ts

@@ -107,15 +107,17 @@ export function validateExtensionBlock(
   const nodeKeys = new Set(Object.keys(node.parameters));
 
   // 1. Unknown parameters — keys in the node not in the descriptor.
-  for (const key of nodeKeys) {
-    if (!descriptorKeys.has(key)) {
-      const captured = node.parameters[key];
-      diagnostics.push({
-        code: 'PSL_EXTENSION_UNKNOWN_PARAMETER',
-        message: `Unknown parameter "${key}" in "${descriptor.keyword}" block "${node.name}". The descriptor does not declare this parameter.`,
-        sourceId,
-        span: captured?.span ?? node.span,
-      });
+  if (!descriptor.variadicParameters) {
+    for (const key of nodeKeys) {
+      if (!descriptorKeys.has(key)) {
+        const captured = node.parameters[key];
+        diagnostics.push({
+          code: 'PSL_EXTENSION_UNKNOWN_PARAMETER',
+          message: `Unknown parameter "${key}" in "${descriptor.keyword}" block "${node.name}". The descriptor does not declare this parameter.`,
+          sourceId,
+          span: captured?.span ?? node.span,
+        });
+      }
     }
   }
 

package/src/exports/authoring.ts

@@ -3,6 +3,7 @@ export type {
   AuthoringArgumentDescriptor,
   AuthoringColumnDefaultTemplate,
   AuthoringContributions,
+  AuthoringDiagnosticSink,
   AuthoringEntityContext,
   AuthoringEntityTypeDescriptor,
   AuthoringEntityTypeFactoryOutput,

package/src/exports/control.ts

@@ -47,7 +47,6 @@ export type {
   MigrationRunnerSuccessValue,
   MigrationScaffoldContext,
   OpFactoryCall,
-  SerializedQueryPlan,
   TargetMigrationsCapability,
 } from '../control/control-migration-types';
 export type {

package/src/shared/framework-authoring.ts

@@ -10,6 +10,7 @@ import {
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Type } from 'arktype';
+import type { CodecLookup } from './codec-types';
 import type { PslBlockParam } from './psl-extension-block';
 
 export type AuthoringArgRef = {
@@ -109,9 +110,30 @@ export type AuthoringFieldNamespace = {
  * discover what the factory actually needs to read (codec lookup,
  * namespace registry, …).
  */
+/**
+ * A write-only sink that a factory may push authoring-time diagnostics into.
+ * The concrete type pushed must be structurally compatible with whatever the
+ * consumer accumulates (typically `ContractSourceDiagnostic[]`); the framework
+ * layer deliberately does not depend on that concrete type.
+ */
+export interface AuthoringDiagnosticSink {
+  push(d: {
+    readonly code: string;
+    readonly message: string;
+    readonly sourceId: string;
+    readonly span?: unknown;
+  }): void;
+}
+
 export interface AuthoringEntityContext {
   readonly family: string;
   readonly target: string;
+  /** Codec registry available to factories that need to validate or decode values. */
+  readonly codecLookup?: CodecLookup;
+  /** Source file identifier threaded into diagnostics emitted by the factory. */
+  readonly sourceId?: string;
+  /** Push channel for authoring-time diagnostics emitted by the factory. */
+  readonly diagnostics?: AuthoringDiagnosticSink;
 }
 
 export interface AuthoringEntityTypeTemplateOutput {
@@ -186,6 +208,21 @@ export interface AuthoringPslBlockDescriptor {
   readonly discriminator: string;
   readonly name: { readonly required: boolean };
   readonly parameters: Record<string, PslBlockParam>;
+  /**
+   * When `true`, the block body accepts a variadic tail of parameters beyond
+   * the declared set. The block body may contain: fields (model-style),
+   * `key = value` parameters, and `@@` attributes. With `variadicParameters`,
+   * bare identifiers (keys without a `= value`) and undeclared `key = value`
+   * pairs flow into the variadic tail — their semantics belong to the
+   * lowering, not the parser.
+   *
+   * A key that IS declared in `parameters` must still be supplied as
+   * `key = value`; a bare occurrence of a declared key is a diagnostic.
+   *
+   * When `false` (default), the validator emits `PSL_EXTENSION_UNKNOWN_PARAMETER`
+   * for keys absent from `parameters`.
+   */
+  readonly variadicParameters?: boolean;
 }
 
 export type AuthoringPslBlockDescriptorNamespace = {
@@ -329,13 +366,29 @@ export function hasRegisteredFieldNamespace(
   return !isAuthoringFieldPresetDescriptor(contributions.field[namespace]);
 }
 
-function isPlainNamespaceObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+function isCopyableNamespaceObject(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const proto: unknown = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function deepCopyNamespace(
+  source: Record<string, unknown>,
+  isLeafDescriptor: (value: unknown) => boolean,
+): Record<string, unknown> {
+  const copy: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(source)) {
+    copy[key] =
+      isCopyableNamespaceObject(value) && !isLeafDescriptor(value)
+        ? deepCopyNamespace(value, isLeafDescriptor)
+        : value;
+  }
+  return copy;
 }
 
 /**
  * Merges `source` into `target` recursively at the descriptor-namespace
- * level. `leafGuard` decides which values are descriptors (terminal
+ * level. `isLeafDescriptor` decides which values are descriptors (terminal
  * merge points; same-path registrations across components are reported
  * as duplicates) versus sub-namespaces (recursion targets).
  *
@@ -355,7 +408,7 @@ export function mergeAuthoringNamespaces(
   target: Record<string, unknown>,
   source: Record<string, unknown>,
   path: readonly string[],
-  leafGuard: (value: unknown) => boolean,
+  isLeafDescriptor: (value: unknown) => boolean,
   label: string,
 ): void {
   const assertSafePath = (currentPath: readonly string[]) => {
@@ -376,12 +429,19 @@ export function mergeAuthoringNamespaces(
     const existingValue = hasExistingValue ? target[key] : undefined;
 
     if (!hasExistingValue) {
-      target[key] = sourceValue;
+      // Deep-copy plain-object sub-namespaces so subsequent merges don't mutate
+      // objects owned by source packs. Leaf descriptors and class instances are
+      // passed by reference — leaves are identity values; class instances carry
+      // prototype getters that spread would destroy.
+      target[key] =
+        isCopyableNamespaceObject(sourceValue) && !isLeafDescriptor(sourceValue)
+          ? deepCopyNamespace(sourceValue, isLeafDescriptor)
+          : sourceValue;
       continue;
     }
 
-    const existingIsLeaf = leafGuard(existingValue);
-    const sourceIsLeaf = leafGuard(sourceValue);
+    const existingIsLeaf = isLeafDescriptor(existingValue);
+    const sourceIsLeaf = isLeafDescriptor(sourceValue);
 
     if (existingIsLeaf || sourceIsLeaf) {
       throw new Error(
@@ -389,17 +449,17 @@ export function mergeAuthoringNamespaces(
       );
     }
 
-    if (!isPlainNamespaceObject(existingValue) || !isPlainNamespaceObject(sourceValue)) {
+    if (!isCopyableNamespaceObject(existingValue) || !isCopyableNamespaceObject(sourceValue)) {
       throw new Error(
         `Invalid authoring ${label} helper "${currentPath.join('.')}". Expected a sub-namespace object or a recognized descriptor; received a malformed value.`,
       );
     }
 
-    mergeAuthoringNamespaces(existingValue, sourceValue, currentPath, leafGuard, label);
+    mergeAuthoringNamespaces(existingValue, sourceValue, currentPath, isLeafDescriptor, label);
   }
 }
 
-function collectAuthoringLeafPaths(
+function collectDescriptorPaths(
   namespace: Readonly<Record<string, unknown>>,
   isLeaf: (value: unknown) => boolean,
   path: readonly string[] = [],
@@ -413,29 +473,25 @@ function collectAuthoringLeafPaths(
     }
     if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
       paths.push(
-        ...collectAuthoringLeafPaths(
-          value as Readonly<Record<string, unknown>>,
-          isLeaf,
-          currentPath,
-        ),
+        ...collectDescriptorPaths(value as Readonly<Record<string, unknown>>, isLeaf, currentPath),
       );
     }
   }
   return paths;
 }
 
-interface AuthoringLeafEntry {
+interface DescriptorEntry {
   readonly path: string;
   readonly discriminator: string;
 }
 
-function collectAuthoringLeafDiscriminators(
+function collectDescriptorEntries(
   namespace: Readonly<Record<string, unknown>>,
   isLeaf: (value: unknown) => boolean,
   label: string,
   path: readonly string[] = [],
-): AuthoringLeafEntry[] {
-  const entries: AuthoringLeafEntry[] = [];
+): DescriptorEntry[] {
+  const entries: DescriptorEntry[] = [];
   for (const [key, value] of Object.entries(namespace)) {
     const currentPath = [...path, key];
     if (isLeaf(value)) {
@@ -479,7 +535,7 @@ function collectAuthoringLeafDiscriminators(
           );
         }
       }
-      entries.push(...collectAuthoringLeafDiscriminators(record, isLeaf, label, currentPath));
+      entries.push(...collectDescriptorEntries(record, isLeaf, label, currentPath));
     }
   }
   return entries;
@@ -491,7 +547,7 @@ function collectAuthoringLeafDiscriminators(
  * lowering factory lookup dispatches by discriminator, so one would silently
  * shadow the other. Catch duplicates before building any dispatch map.
  */
-function assertUniqueDiscriminators(entries: readonly AuthoringLeafEntry[], label: string): void {
+function assertUniqueDiscriminators(entries: readonly DescriptorEntry[], label: string): void {
   const seen = new Map<string, string>();
   for (const { path, discriminator } of entries) {
     const existing = seen.get(discriminator);
@@ -504,23 +560,50 @@ function assertUniqueDiscriminators(entries: readonly AuthoringLeafEntry[], labe
   }
 }
 
+function collectPslBlockDescriptorEntries(
+  namespace: Readonly<Record<string, unknown>>,
+  path: readonly string[] = [],
+): DescriptorEntry[] {
+  const entries: DescriptorEntry[] = [];
+  for (const [key, value] of Object.entries(namespace)) {
+    const currentPath = [...path, key];
+    if (isAuthoringPslBlockDescriptor(value)) {
+      entries.push({
+        path: currentPath.join('.'),
+        discriminator: value.discriminator,
+      });
+      continue;
+    }
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const record = blindCast<
+        Readonly<Record<string, unknown>>,
+        'walker descends into psl block namespace'
+      >(value);
+      const hasKind = record['kind'] === 'pslBlock';
+      const hasKeyword = typeof record['keyword'] === 'string';
+      const hasDiscriminator = typeof record['discriminator'] === 'string';
+      if (hasKind || (hasKeyword && hasDiscriminator)) {
+        throw new Error(
+          `Malformed authoring pslBlock contribution at "${currentPath.join('.')}". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the pslBlock descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`,
+        );
+      }
+      entries.push(...collectPslBlockDescriptorEntries(record, currentPath));
+    }
+  }
+  return entries;
+}
+
 /**
- * Every `pslBlockDescriptors` entry needs a matching `entityTypes` factory
- * (same discriminator): the parser would otherwise produce an AST node
- * nothing can lower to an IR class instance. The link is one-directional
- * — an `entityTypes` factory may stand alone (e.g. `enum`, reachable from
- * the TypeScript builder without any PSL block).
+ * Every `pslBlockDescriptors` entry requires a matching `entityTypes` factory
+ * with the same discriminator. An `entityTypes` factory may stand alone (e.g.
+ * `enum`, reachable from the TypeScript builder without any PSL block).
  */
 function assertPslBlocksHaveFactories(
   entityTypeNamespace: AuthoringEntityTypeNamespace,
   pslBlockNamespace: AuthoringPslBlockDescriptorNamespace,
 ): void {
-  const blockEntries = collectAuthoringLeafDiscriminators(
-    pslBlockNamespace,
-    isAuthoringPslBlockDescriptor,
-    'pslBlock',
-  );
-  const entityEntries = collectAuthoringLeafDiscriminators(
+  const blockEntries = collectPslBlockDescriptorEntries(pslBlockNamespace);
+  const entityEntries = collectDescriptorEntries(
     entityTypeNamespace,
     isAuthoringEntityTypeDescriptor,
     'entityType',
@@ -547,13 +630,13 @@ export function assertNoCrossRegistryCollisions(
   pslBlockNamespace: AuthoringPslBlockDescriptorNamespace = {},
 ): void {
   const typePaths = new Set(
-    collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),
+    collectDescriptorPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),
   );
   const fieldPaths = new Set(
-    collectAuthoringLeafPaths(fieldNamespace, isAuthoringFieldPresetDescriptor),
+    collectDescriptorPaths(fieldNamespace, isAuthoringFieldPresetDescriptor),
   );
   const entityPaths = new Set(
-    collectAuthoringLeafPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor),
+    collectDescriptorPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor),
   );
   // Within-registry duplicate detection is handled upstream by the merge
   // walker (`mergeAuthoringNamespaces` in control-stack.ts and