@prisma-next/framework-components 0.12.0 → 0.13.0-dev.10

package/dist/ir.mjs

@@ -68,22 +68,25 @@ var NamespaceBase = class extends IRNodeBase {};
 * value, yielded as {@link EntityCoordinate} tuples with
 * `plane: 'storage'` (the parameter type binds the plane).
 *
-* Iterates each namespace's own-enumerable properties structurally.
-* Skips `id` (known scalar); `kind` is non-enumerable on namespace
-* concretions and does not appear in `Object.entries`. For every other
-* property whose value is a non-null object, yields one coordinate per
-* entry key in that map. No family-specific slot vocabulary is required.
+* Iterates each namespace's `entries` slot maps structurally. Skips
+* non-object `entries`; `id` and `kind` are not walked (`kind` is
+* non-enumerable on concretions). For every entity-kind key under
+* `entries` whose value is a non-null object, yields one coordinate per
+* entity name in that map. No family-specific slot vocabulary is required.
 */
 function* elementCoordinates(storage) {
-	for (const [namespaceId, ns] of Object.entries(storage.namespaces)) for (const [entityKind, slot] of Object.entries(ns)) {
-		if (entityKind === "id") continue;
-		if (slot === null || typeof slot !== "object") continue;
-		for (const entityName of Object.keys(slot)) yield {
-			plane: "storage",
-			namespaceId,
-			entityKind,
-			entityName
-		};
+	for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
+		const entries = ns.entries;
+		if (entries === null || typeof entries !== "object") continue;
+		for (const [entityKind, slot] of Object.entries(entries)) {
+			if (slot === null || typeof slot !== "object") continue;
+			for (const entityName of Object.keys(slot)) yield {
+				plane: "storage",
+				namespaceId,
+				entityKind,
+				entityName
+			};
+		}
 	}
 }
 //#endregion

package/dist/ir.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ir.mjs","names":[],"sources":["../src/ir/domain.ts","../src/ir/ir-node.ts","../src/ir/namespace.ts","../src/ir/storage.ts"],"sourcesContent":["import type { ApplicationDomain } from '@prisma-next/contract/types';\nimport type { EntityCoordinate } from './storage';\n\n/**\n * Lazy walk over every named domain entity in a {@link ApplicationDomain},\n * yielded as {@link EntityCoordinate} tuples with `plane: 'domain'`.\n *\n * Same structural rules as {@link elementCoordinates} over storage: skip\n * scalar `id`; each other object-valued property is an entity-kind slot.\n */\nexport function* domainElementCoordinates(\n  domain: Pick<ApplicationDomain, 'namespaces'>,\n): Generator<EntityCoordinate> {\n  for (const [namespaceId, ns] of Object.entries(domain.namespaces)) {\n    for (const [entityKind, slot] of Object.entries(ns)) {\n      if (entityKind === 'id') continue;\n      if (slot === null || typeof slot !== 'object') continue;\n      for (const entityName of Object.keys(slot)) {\n        yield { plane: 'domain', namespaceId, entityKind, entityName };\n      }\n    }\n  }\n}\n","/**\n * Framework-level IR alphabet.\n *\n * The framework's contribution to Contract IR / Schema IR is a common\n * root for the IR class hierarchy and a freeze affordance. Family\n * abstract bases (e.g. `SqlNode`, `MongoSchemaIRNode`) refine the alphabet\n * for their family shape; targets ship the concrete classes.\n *\n * `kind` is an optional discriminator on the base. Families and leaves\n * that benefit from discriminated-union dispatch declare their own\n * literal `kind` at the level that earns it — Mongo leaves carry\n * per-class literals (`readonly kind = 'mongo-collection' as const`)\n * because Mongo IR has polymorphic walkers; SQL declares a single\n * family-level `kind = 'sql'` on `SqlNode` because SQL IR has no\n * polymorphic dispatch today. No framework consumer dispatches on\n * `IRNode.kind` at the BASE type — every dispatch site narrows\n * through a union of leaves where each leaf carries a literal kind, so\n * requiring `kind` at the base would be unearned. Future leaves that\n * earn polymorphic dispatch override with a required literal at that\n * leaf (e.g. `override readonly kind = 'pack-contributed-kind' as const`).\n *\n * `IRNodeBase` carries no methods: the freeze-and-assign affordance\n * lives in the free `freezeNode` helper below. Keeping `freezeNode` out\n * of the class type means an emitted contract literal type\n * (`{ readonly kind: 'mongo-collection', ... }` or an unkeyed literal\n * like `{ nativeType, codecId, nullable }`) is structurally assignable\n * to its class type — a `protected freeze()` instance method would\n * otherwise leak into the public type surface and require the literal\n * to carry it too.\n *\n * Subclasses construct fields then call `freezeNode(this)` to seal the\n * instance. Frozen instances + plain readonly fields keep IR nodes\n * JSON-clean by construction, so `JSON.stringify(node)` produces canonical\n * JSON without a `toJSON()` method. The `ContractSerializer` SPI handles\n * round-trip from canonical JSON back to typed class instances.\n *\n * The name (`IRNode` / `IRNodeBase`) reflects the dual-hierarchy reality:\n * this base is the common root for both Contract IR and Schema IR class\n * hierarchies, not a Schema-IR-specific alphabet.\n */\n\nexport interface IRNode {\n  readonly kind?: string;\n}\n\nexport abstract class IRNodeBase implements IRNode {\n  abstract readonly kind?: string;\n}\n\n/**\n * Seal an IR class instance after its constructor has assigned all\n * fields. The free-helper form (rather than a `protected freeze()`\n * instance method) keeps the class type structurally narrow so emitted\n * contract literal types remain assignable to their class types.\n *\n * The helper name stays `freezeNode` — it operates on IR nodes\n * regardless of root naming.\n */\nexport function freezeNode<T extends IRNode>(node: T): T {\n  Object.freeze(node);\n  return node;\n}\n","import type { StorageNamespace } from '@prisma-next/contract/types';\nimport { type IRNode, IRNodeBase } from './ir-node';\n\n/**\n * Reserved sentinel namespace id for the late-bound storage slot —\n * the slot whose binding the target resolves at connection time\n * rather than at authoring time. Postgres uses it for `search_path`\n * late binding; SQLite uses it for the trivial singleton; Mongo uses\n * it for the connection's `db` binding.\n *\n * Materialised target-side as a singleton subclass of the target's\n * `NamespaceBase` concretion that overrides the namespace's\n * qualifier-emission methods to elide the prefix entirely. Call sites\n * stay polymorphic and never branch on `id === UNBOUND_NAMESPACE_ID`\n * — the singleton's overrides drop the qualifier so emitted SQL / Mongo\n * commands look unqualified.\n *\n * The double-underscore decoration marks the id as a framework-reserved\n * coordinate when it appears in a JSON envelope (cold-read-as-reserved\n * — no realistic collision with user-declared namespace names).\n *\n * Encoded as an exported const (rather than scattered string literals)\n * so the sentinel-id invariant is single-sourced: any production-source\n * site that constructs an unbound-namespace singleton imports this\n * constant.\n */\nexport const UNBOUND_NAMESPACE_ID = '__unbound__' as const;\n\n/**\n * Framework-level building block for a \"namespace\" — the database-level\n * grouping under which storage objects (tables, collections, enums, …)\n * reside. Each target's namespace concretion maps the framework concept to\n * a target-native binding:\n *\n * - Postgres: a schema (`CREATE SCHEMA …`); rendered as `\"<schema>\"`.\n * - SQLite: the singleton `UNBOUND_NAMESPACE_ID`; emitted SQL has no qualifier.\n * - Mongo: the connection's `db` field; addressed as a database name.\n *\n * See `UNBOUND_NAMESPACE_ID` above for the sentinel id and the\n * singleton-subclass pattern that materialises it.\n *\n * The framework promises only the coordinate (`id`) — the named storage\n * entities a namespace contains are family-typed (SQL contributes\n * `tables`, Mongo contributes `collections`, future families pick their\n * own native idiom). Generic consumers walking \"all named entries\" go\n * through a family-typed namespace, not the framework `Namespace`.\n *\n * Every namespace concretion (e.g. family-built SQL namespaces,\n * `MongoUnboundNamespace`, target-promoted namespaces like\n * `PostgresSchema`) carries exactly: `id` (enumerable string), `kind`\n * (non-enumerable string discriminator set via `Object.defineProperty`),\n * and one or more entity-kind slot maps — each an own-enumerable property\n * whose key is the entity kind (`tables`, `types`, `collections`,\n * target-pack-contributed slot names) and whose value is a\n * `Record<entityName, EntityIRClass>`. No other own-enumerable data lives\n * on a namespace; non-entity computed data lives on the surrounding storage\n * or contract IR. The framework's `elementCoordinates(storage)` walk relies\n * on this invariant to enumerate entities structurally without\n * family-specific knowledge.\n */\nexport interface Namespace extends IRNode, StorageNamespace {\n  readonly kind: string;\n}\n\nexport abstract class NamespaceBase extends IRNodeBase implements Namespace {\n  abstract readonly id: string;\n  abstract override readonly kind: string;\n}\n","import type { StorageBase } from '@prisma-next/contract/types';\nimport type { IRNode } from './ir-node';\nimport type { Namespace } from './namespace';\n\n/**\n * Canonical address for a named entity in Contract IR / Schema IR.\n *\n * `plane` is `'domain' | 'storage'`: which top-level contract plane the\n * entity lives on. Domain-side walks yield `plane: 'domain'` via\n * {@link domainElementCoordinates}; {@link elementCoordinates} over storage\n * yields `plane: 'storage'`.\n *\n * Cross-plane references obey a directional invariant: domain → storage is\n * allowed; storage → domain is forbidden. That rule is enforced by a\n * separate validator, not by constraining this coordinate shape — the\n * coordinate carries the axis the validator checks.\n *\n * Iteration order over namespace properties follows `Object.entries` order;\n * consumers that depend on ordering must sort.\n */\nexport interface EntityCoordinate {\n  readonly plane: 'domain' | 'storage';\n  readonly namespaceId: string;\n  readonly entityKind: string;\n  readonly entityName: string;\n}\n\n/**\n * Lazy walk over every named storage entity in a `Storage`-shaped\n * value, yielded as {@link EntityCoordinate} tuples with\n * `plane: 'storage'` (the parameter type binds the plane).\n *\n * Iterates each namespace's own-enumerable properties structurally.\n * Skips `id` (known scalar); `kind` is non-enumerable on namespace\n * concretions and does not appear in `Object.entries`. For every other\n * property whose value is a non-null object, yields one coordinate per\n * entry key in that map. No family-specific slot vocabulary is required.\n */\nexport function* elementCoordinates(\n  storage: Pick<StorageBase, 'namespaces'>,\n): Generator<EntityCoordinate> {\n  for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {\n    for (const [entityKind, slot] of Object.entries(ns)) {\n      if (entityKind === 'id') continue;\n      if (slot === null || typeof slot !== 'object') continue;\n      for (const entityName of Object.keys(slot)) {\n        yield { plane: 'storage', namespaceId, entityKind, entityName };\n      }\n    }\n  }\n}\n\n/**\n * Framework-level promise that every Contract IR / Schema IR carries a\n * collection of namespaces keyed by namespace id. Family storage\n * concretions (`SqlStorage`, `MongoStorage`) refine the shape with\n * family-specific fields (tables, collections, enums, …); target\n * concretions add target fields where the family vocabulary doesn't\n * reach.\n *\n * Keeping `namespaces` at the framework layer enforces that every storage\n * object — across any target — is namespace-scoped. The framework can\n * therefore walk the namespace map without knowing the family alphabet, and\n * the `(namespace.id, name)` keying that the verifier and planner depend on\n * is honest at every layer.\n *\n * Extends `IRNode` so the framework's IR-walking surfaces (verifiers,\n * serializers) can dispatch on `Storage`-typed slots through the same\n * IR-node alphabet as every other node — the structural dual already\n * holds in code (every concrete storage class extends an IR-node base);\n * the interface promotion makes the typing honest.\n *\n * **Persisted envelope shape is target-owned, not framework-promised.**\n * Whether the `namespaces` map appears in the on-disk JSON envelope is\n * a per-target decision made by `ContractSerializer.serializeContract`.\n * Some targets emit a JSON-clean namespace shape that round-trips\n * through `JSON.stringify` cleanly (SQL today via the family-layer\n * identity serializer); others ship runtime-only fields on their\n * namespace concretions and override `serializeContract` to strip\n * them (Mongo). Future open (F16): extend the per-target\n * `ContractSerializer` integration-test surface with an explicit\n * envelope-shape assertion for each target, so the strip-vs-pass-through\n * choice is locked at test time rather than implied by the override\n * presence/absence. Earned by PR2's per-target namespace lift, when\n * `PostgresSchema` / `SqliteUnboundDatabase` start carrying\n * target-specific fields.\n */\nexport interface Storage extends IRNode {\n  readonly namespaces: Readonly<Record<string, Namespace>>;\n}\n"],"mappings":";;;;;;;;AAUA,UAAiB,yBACf,QAC6B;CAC7B,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,OAAO,UAAU,GAC9D,KAAK,MAAM,CAAC,YAAY,SAAS,OAAO,QAAQ,EAAE,GAAG;EACnD,IAAI,eAAe,MAAM;EACzB,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;EAC/C,KAAK,MAAM,cAAc,OAAO,KAAK,IAAI,GACvC,MAAM;GAAE,OAAO;GAAU;GAAa;GAAY;EAAW;CAEjE;AAEJ;;;ACuBA,IAAsB,aAAtB,MAAmD,CAEnD;;;;;;;;;;AAWA,SAAgB,WAA6B,MAAY;CACvD,OAAO,OAAO,IAAI;CAClB,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,MAAa,uBAAuB;AAsCpC,IAAsB,gBAAtB,cAA4C,WAAgC,CAG5E;;;;;;;;;;;;;;AC7BA,UAAiB,mBACf,SAC6B;CAC7B,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,QAAQ,UAAU,GAC/D,KAAK,MAAM,CAAC,YAAY,SAAS,OAAO,QAAQ,EAAE,GAAG;EACnD,IAAI,eAAe,MAAM;EACzB,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;EAC/C,KAAK,MAAM,cAAc,OAAO,KAAK,IAAI,GACvC,MAAM;GAAE,OAAO;GAAW;GAAa;GAAY;EAAW;CAElE;AAEJ"}
+{"version":3,"file":"ir.mjs","names":[],"sources":["../src/ir/domain.ts","../src/ir/ir-node.ts","../src/ir/namespace.ts","../src/ir/storage.ts"],"sourcesContent":["import type { ApplicationDomain } from '@prisma-next/contract/types';\nimport type { EntityCoordinate } from './storage';\n\n/**\n * Lazy walk over every named domain entity in a {@link ApplicationDomain},\n * yielded as {@link EntityCoordinate} tuples with `plane: 'domain'`.\n *\n * Same structural rules as {@link elementCoordinates} over storage: skip\n * scalar `id`; each other object-valued property is an entity-kind slot.\n */\nexport function* domainElementCoordinates(\n  domain: Pick<ApplicationDomain, 'namespaces'>,\n): Generator<EntityCoordinate> {\n  for (const [namespaceId, ns] of Object.entries(domain.namespaces)) {\n    for (const [entityKind, slot] of Object.entries(ns)) {\n      if (entityKind === 'id') continue;\n      if (slot === null || typeof slot !== 'object') continue;\n      for (const entityName of Object.keys(slot)) {\n        yield { plane: 'domain', namespaceId, entityKind, entityName };\n      }\n    }\n  }\n}\n","/**\n * Framework-level IR alphabet.\n *\n * The framework's contribution to Contract IR / Schema IR is a common\n * root for the IR class hierarchy and a freeze affordance. Family\n * abstract bases (e.g. `SqlNode`, `MongoSchemaIRNode`) refine the alphabet\n * for their family shape; targets ship the concrete classes.\n *\n * `kind` is an optional discriminator on the base. Families and leaves\n * that benefit from discriminated-union dispatch declare their own\n * literal `kind` at the level that earns it — Mongo leaves carry\n * per-class literals (`readonly kind = 'mongo-collection' as const`)\n * because Mongo IR has polymorphic walkers; SQL declares a single\n * family-level `kind = 'sql'` on `SqlNode` because SQL IR has no\n * polymorphic dispatch today. No framework consumer dispatches on\n * `IRNode.kind` at the BASE type — every dispatch site narrows\n * through a union of leaves where each leaf carries a literal kind, so\n * requiring `kind` at the base would be unearned. Future leaves that\n * earn polymorphic dispatch override with a required literal at that\n * leaf (e.g. `override readonly kind = 'pack-contributed-kind' as const`).\n *\n * `IRNodeBase` carries no methods: the freeze-and-assign affordance\n * lives in the free `freezeNode` helper below. Keeping `freezeNode` out\n * of the class type means an emitted contract literal type\n * (`{ readonly kind: 'mongo-collection', ... }` or an unkeyed literal\n * like `{ nativeType, codecId, nullable }`) is structurally assignable\n * to its class type — a `protected freeze()` instance method would\n * otherwise leak into the public type surface and require the literal\n * to carry it too.\n *\n * Subclasses construct fields then call `freezeNode(this)` to seal the\n * instance. Frozen instances + plain readonly fields keep IR nodes\n * JSON-clean by construction, so `JSON.stringify(node)` produces canonical\n * JSON without a `toJSON()` method. The `ContractSerializer` SPI handles\n * round-trip from canonical JSON back to typed class instances.\n *\n * The name (`IRNode` / `IRNodeBase`) reflects the dual-hierarchy reality:\n * this base is the common root for both Contract IR and Schema IR class\n * hierarchies, not a Schema-IR-specific alphabet.\n */\n\nexport interface IRNode {\n  readonly kind?: string;\n}\n\nexport abstract class IRNodeBase implements IRNode {\n  abstract readonly kind?: string;\n}\n\n/**\n * Seal an IR class instance after its constructor has assigned all\n * fields. The free-helper form (rather than a `protected freeze()`\n * instance method) keeps the class type structurally narrow so emitted\n * contract literal types remain assignable to their class types.\n *\n * The helper name stays `freezeNode` — it operates on IR nodes\n * regardless of root naming.\n */\nexport function freezeNode<T extends IRNode>(node: T): T {\n  Object.freeze(node);\n  return node;\n}\n","import type { StorageNamespace } from '@prisma-next/contract/types';\nimport { type IRNode, IRNodeBase } from './ir-node';\n\n/**\n * Reserved sentinel namespace id for the late-bound storage slot —\n * the slot whose binding the target resolves at connection time\n * rather than at authoring time. Postgres uses it for `search_path`\n * late binding; SQLite uses it for the trivial singleton; Mongo uses\n * it for the connection's `db` binding.\n *\n * Materialised target-side as a singleton subclass of the target's\n * `NamespaceBase` concretion that overrides the namespace's\n * qualifier-emission methods to elide the prefix entirely. Call sites\n * stay polymorphic and never branch on `id === UNBOUND_NAMESPACE_ID`\n * — the singleton's overrides drop the qualifier so emitted SQL / Mongo\n * commands look unqualified.\n *\n * The double-underscore decoration marks the id as a framework-reserved\n * coordinate when it appears in a JSON envelope (cold-read-as-reserved\n * — no realistic collision with user-declared namespace names).\n *\n * Encoded as an exported const (rather than scattered string literals)\n * so the sentinel-id invariant is single-sourced: any production-source\n * site that constructs an unbound-namespace singleton imports this\n * constant.\n */\nexport const UNBOUND_NAMESPACE_ID = '__unbound__' as const;\n\n/**\n * Framework-level building block for a \"namespace\" — the database-level\n * grouping under which storage objects (tables, collections, enums, …)\n * reside. Each target's namespace concretion maps the framework concept to\n * a target-native binding:\n *\n * - Postgres: a schema (`CREATE SCHEMA …`); rendered as `\"<schema>\"`.\n * - SQLite: the singleton `UNBOUND_NAMESPACE_ID`; emitted SQL has no qualifier.\n * - Mongo: the connection's `db` field; addressed as a database name.\n *\n * See `UNBOUND_NAMESPACE_ID` above for the sentinel id and the\n * singleton-subclass pattern that materialises it.\n *\n * The framework promises only the coordinate (`id`) — the named storage\n * entities a namespace contains are family-typed (SQL contributes\n * `table` / `type`, Mongo contributes `collection`, future families pick\n * their own native idiom under `entries`). Generic consumers walking \"all\n * named entries\" go through a family-typed namespace, not the framework\n * `Namespace`.\n *\n * Every namespace concretion (e.g. family-built SQL namespaces,\n * `MongoUnboundNamespace`, target-promoted namespaces like\n * `PostgresSchema`) carries exactly: `id` (enumerable string),\n * `entries` (frozen object holding entity-kind slot maps), and `kind`\n * (non-enumerable string discriminator set via `Object.defineProperty`).\n * Each slot map under `entries` uses a singular essence key (`table`,\n * `type`, `collection`, …) mapping entity names to IR classes. No other\n * own-enumerable data lives on a namespace; non-entity computed data lives\n * on the surrounding storage or contract IR. The framework's\n * `elementCoordinates(storage)` walk relies on this invariant to enumerate\n * entities structurally without family-specific knowledge.\n */\nexport interface Namespace extends IRNode, StorageNamespace {\n  readonly kind: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\n}\n\nexport abstract class NamespaceBase extends IRNodeBase implements Namespace {\n  abstract readonly id: string;\n  abstract readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\n  abstract override readonly kind: string;\n}\n","import type { StorageBase } from '@prisma-next/contract/types';\nimport type { IRNode } from './ir-node';\nimport type { Namespace } from './namespace';\n\n/**\n * Canonical address for a named entity in Contract IR / Schema IR.\n *\n * `plane` is `'domain' | 'storage'`: which top-level contract plane the\n * entity lives on. Domain-side walks yield `plane: 'domain'` via\n * {@link domainElementCoordinates}; {@link elementCoordinates} over storage\n * yields `plane: 'storage'`.\n *\n * Cross-plane references obey a directional invariant: domain → storage is\n * allowed; storage → domain is forbidden. That rule is enforced by a\n * separate validator, not by constraining this coordinate shape — the\n * coordinate carries the axis the validator checks.\n *\n * Iteration order over namespace properties follows `Object.entries` order;\n * consumers that depend on ordering must sort.\n */\nexport interface EntityCoordinate {\n  readonly plane: 'domain' | 'storage';\n  readonly namespaceId: string;\n  readonly entityKind: string;\n  readonly entityName: string;\n}\n\n/**\n * Lazy walk over every named storage entity in a `Storage`-shaped\n * value, yielded as {@link EntityCoordinate} tuples with\n * `plane: 'storage'` (the parameter type binds the plane).\n *\n * Iterates each namespace's `entries` slot maps structurally. Skips\n * non-object `entries`; `id` and `kind` are not walked (`kind` is\n * non-enumerable on concretions). For every entity-kind key under\n * `entries` whose value is a non-null object, yields one coordinate per\n * entity name in that map. No family-specific slot vocabulary is required.\n */\nexport function* elementCoordinates(\n  storage: Pick<StorageBase, 'namespaces'>,\n): Generator<EntityCoordinate> {\n  for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {\n    const entries = ns.entries;\n    if (entries === null || typeof entries !== 'object') continue;\n    for (const [entityKind, slot] of Object.entries(entries)) {\n      if (slot === null || typeof slot !== 'object') continue;\n      for (const entityName of Object.keys(slot)) {\n        yield { plane: 'storage', namespaceId, entityKind, entityName };\n      }\n    }\n  }\n}\n\n/**\n * Framework-level promise that every Contract IR / Schema IR carries a\n * collection of namespaces keyed by namespace id. Family storage\n * concretions (`SqlStorage`, `MongoStorage`) refine the shape with\n * family-specific fields (tables, collections, enums, …); target\n * concretions add target fields where the family vocabulary doesn't\n * reach.\n *\n * Keeping `namespaces` at the framework layer enforces that every storage\n * object — across any target — is namespace-scoped. The framework can\n * therefore walk the namespace map without knowing the family alphabet, and\n * the `(namespace.id, name)` keying that the verifier and planner depend on\n * is honest at every layer.\n *\n * Extends `IRNode` so the framework's IR-walking surfaces (verifiers,\n * serializers) can dispatch on `Storage`-typed slots through the same\n * IR-node alphabet as every other node — the structural dual already\n * holds in code (every concrete storage class extends an IR-node base);\n * the interface promotion makes the typing honest.\n *\n * **Persisted envelope shape is target-owned, not framework-promised.**\n * Whether the `namespaces` map appears in the on-disk JSON envelope is\n * a per-target decision made by `ContractSerializer.serializeContract`.\n * Some targets emit a JSON-clean namespace shape that round-trips\n * through `JSON.stringify` cleanly (SQL today via the family-layer\n * identity serializer); others ship runtime-only fields on their\n * namespace concretions and override `serializeContract` to strip\n * them (Mongo). Future open (F16): extend the per-target\n * `ContractSerializer` integration-test surface with an explicit\n * envelope-shape assertion for each target, so the strip-vs-pass-through\n * choice is locked at test time rather than implied by the override\n * presence/absence. Earned by PR2's per-target namespace lift, when\n * `PostgresSchema` / `SqliteUnboundDatabase` start carrying\n * target-specific fields.\n */\nexport interface Storage extends IRNode {\n  readonly namespaces: Readonly<Record<string, Namespace>>;\n}\n"],"mappings":";;;;;;;;AAUA,UAAiB,yBACf,QAC6B;CAC7B,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,OAAO,UAAU,GAC9D,KAAK,MAAM,CAAC,YAAY,SAAS,OAAO,QAAQ,EAAE,GAAG;EACnD,IAAI,eAAe,MAAM;EACzB,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;EAC/C,KAAK,MAAM,cAAc,OAAO,KAAK,IAAI,GACvC,MAAM;GAAE,OAAO;GAAU;GAAa;GAAY;EAAW;CAEjE;AAEJ;;;ACuBA,IAAsB,aAAtB,MAAmD,CAEnD;;;;;;;;;;AAWA,SAAgB,WAA6B,MAAY;CACvD,OAAO,OAAO,IAAI;CAClB,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,MAAa,uBAAuB;AAuCpC,IAAsB,gBAAtB,cAA4C,WAAgC,CAI5E;;;;;;;;;;;;;;AC/BA,UAAiB,mBACf,SAC6B;CAC7B,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,QAAQ,UAAU,GAAG;EAClE,MAAM,UAAU,GAAG;EACnB,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;EACrD,KAAK,MAAM,CAAC,YAAY,SAAS,OAAO,QAAQ,OAAO,GAAG;GACxD,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;GAC/C,KAAK,MAAM,cAAc,OAAO,KAAK,IAAI,GACvC,MAAM;IAAE,OAAO;IAAW;IAAa;IAAY;GAAW;EAElE;CACF;AACF"}

package/dist/{psl-ast-BDXL7iCg.d.mts → psl-ast-Cn50B-UG.d.mts}

@@ -1,14 +1,7 @@
+import { G as PslSpan, L as PslDiagnosticCode, R as PslExtensionBlock, m as AuthoringPslBlockDescriptorNamespace } from "./framework-authoring-R0TYCkvG.mjs";
+import { c as CodecLookup } from "./codec-DCQAerzB.mjs";
+
 //#region src/control/psl-ast.d.ts
-interface PslPosition {
-  readonly offset: number;
-  readonly line: number;
-  readonly column: number;
-}
-interface PslSpan {
-  readonly start: PslPosition;
-  readonly end: PslPosition;
-}
-type PslDiagnosticCode = 'PSL_UNTERMINATED_BLOCK' | 'PSL_UNSUPPORTED_TOP_LEVEL_BLOCK' | 'PSL_INVALID_NAMESPACE_BLOCK' | 'PSL_INVALID_ATTRIBUTE_SYNTAX' | 'PSL_INVALID_MODEL_MEMBER' | 'PSL_UNSUPPORTED_MODEL_ATTRIBUTE' | 'PSL_UNSUPPORTED_FIELD_ATTRIBUTE' | 'PSL_INVALID_RELATION_ATTRIBUTE' | 'PSL_INVALID_REFERENTIAL_ACTION' | 'PSL_INVALID_DEFAULT_VALUE' | 'PSL_INVALID_ENUM_MEMBER' | 'PSL_INVALID_TYPES_MEMBER' | 'PSL_INVALID_QUALIFIED_TYPE';
 interface PslDiagnostic {
   readonly code: PslDiagnosticCode;
   readonly message: string;
@@ -55,10 +48,19 @@ type PslFieldAttribute = PslAttribute;
 interface PslField {
   readonly kind: 'field';
   readonly name: string;
-  /** Unqualified type name, e.g. `"User"` for both `User` and `auth.User`. */
+  /** Unqualified type name, e.g. `"User"` for both `User`, `auth.User`, and `supabase:auth.User`. */
   readonly typeName: string;
-  /** Namespace qualifier from a dot-qualified type reference, e.g. `"auth"` for `auth.User`. Absent for unqualified types. */
+  /** Namespace qualifier from a dot-qualified type reference, e.g. `"auth"` for `auth.User` or `supabase:auth.User`. Absent for unqualified types. */
   readonly typeNamespaceId?: string;
+  /**
+   * Contract-space qualifier from a colon-prefix type reference, e.g. `"supabase"` for
+   * `supabase:auth.User` or `supabase:User`. Absent for local (same-space) type references.
+   *
+   * When present, the field references a model from a different contract space. The namespace
+   * (`typeNamespaceId`) and model name (`typeName`) identify the target within that space.
+   * Physical table resolution against the extension contract is deferred to the aggregate stage (M3).
+   */
+  readonly typeContractSpaceId?: string;
   readonly typeConstructor?: PslTypeConstructorCall;
   readonly optional: boolean;
   readonly list: boolean;
@@ -114,6 +116,11 @@ interface PslEnum {
   readonly attributes: readonly PslAttribute[];
   readonly span: PslSpan;
 }
+/**
+ * A reusable group of fields embedded in a model (a `type Name { … }` block) —
+ * e.g. a MongoDB embedded document or a Postgres composite type. Unlike
+ * {@link PslModel} it has no storage or identity of its own.
+ */
 interface PslCompositeType {
   readonly kind: 'compositeType';
   readonly name: string;
@@ -152,21 +159,43 @@ interface PslTypesBlock {
  * (or whether) to map the PSL bucket to the IR sentinel.
  */
 declare const UNSPECIFIED_PSL_NAMESPACE_ID = "__unspecified__";
+/** A value in {@link PslNamespace.entries}: a built-in entity node or an extension-contributed {@link PslExtensionBlock}. */
+type PslNamespaceEntry = PslModel | PslEnum | PslCompositeType | PslExtensionBlock;
 /**
- * A named namespace block from a PSL document, or the parser's synthesised
- * `__unspecified__` bucket for declarations that appear outside any
- * `namespace { … }` block. Multiple `namespace foo { … }` blocks for the
- * same name across one or more files reopen-merge into a single entry;
+ * A namespace block, or the parser's synthesised `__unspecified__` bucket for
+ * declarations outside any `namespace { … }`. Same-name blocks reopen-merge;
  * `span` points at the first opening.
+ *
+ * Entities are stored canonically (ADR 224) in `entries[kind][name]`, where
+ * `kind` is the PSL keyword for built-ins or the block discriminator for
+ * extension kinds, e.g. `entries['policy_select']['ReadPosts']`.
  */
 interface PslNamespace {
   readonly kind: 'namespace';
   readonly name: string;
+  /** Canonical store: a frozen container of frozen per-kind maps. The accessors below derive from it. */
+  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;
+  /** Built-in models, from `entries['model']`. Extension kinds: {@link namespacePslExtensionBlocks}. */
   readonly models: readonly PslModel[];
+  /** Built-in enums, from `entries['enum']`. */
   readonly enums: readonly PslEnum[];
+  /** Built-in composite types, from `entries['compositeType']`. */
   readonly compositeTypes: readonly PslCompositeType[];
   readonly span: PslSpan;
 }
+/** Constructs a {@link PslNamespace}. Use this, never a namespace literal — the accessors must derive from `entries`. */
+declare function makePslNamespace(init: {
+  readonly kind: 'namespace';
+  readonly name: string;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;
+  readonly span: PslSpan;
+}): PslNamespace;
+/**
+ * Builds the frozen `entries[kind][name]` container from per-kind arrays.
+ * Built-ins key on their PSL keyword; extension blocks key on their `kind`
+ * discriminator. Call this rather than hand-building the literal.
+ */
+declare function makePslNamespaceEntries(models: readonly PslModel[], enums: readonly PslEnum[], compositeTypes: readonly PslCompositeType[], extensionBlocks: readonly PslExtensionBlock[]): Readonly<Record<string, Readonly<Record<string, PslNamespaceEntry>>>>;
 interface PslDocumentAst {
   readonly kind: 'document';
   readonly sourceId: string;
@@ -187,9 +216,52 @@ declare function flatPslEnums(ast: PslDocumentAst): readonly PslEnum[];
  * Returns all composite types from every namespace in document order.
  */
 declare function flatPslCompositeTypes(ast: PslDocumentAst): readonly PslCompositeType[];
+/**
+ * The set of `entries` kind keys that the framework parser reserves for
+ * built-in PSL entity kinds. Any own-enumerable key on `PslNamespace.entries`
+ * that is **not** in this set was contributed by an extension-block descriptor.
+ *
+ * Built-in keys match the PSL keyword used on each block type:
+ * `'model'`, `'enum'`, `'compositeType'`.
+ */
+declare const BUILTIN_PSL_KIND_KEYS: ReadonlySet<string>;
+/**
+ * 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
+ * (`'model'`, `'enum'`, `'compositeType'`). All remaining kind maps contain
+ * only `PslExtensionBlock` nodes by construction (see `makePslNamespaceEntries`).
+ */
+declare function namespacePslExtensionBlocks(ns: PslNamespace): readonly PslExtensionBlock[];
 interface ParsePslDocumentInput {
   readonly schema: string;
   readonly sourceId: string;
+  /**
+   * Registry of declarative block descriptors, keyed by arbitrary path
+   * segments with {@link AuthoringPslBlockDescriptor} leaves. The registry
+   * teaches the parser which top-level keywords belong to extension
+   * contributions: when the parser encounters an unknown keyword, it looks
+   * it up here and, when found, reads the block generically into a
+   * {@link PslExtensionBlock} node. Absent or undefined means no extension
+   * blocks are registered and any unknown keyword yields
+   * `PSL_UNSUPPORTED_TOP_LEVEL_BLOCK`.
+   *
+   * Contrast with the parsed block nodes themselves, which live in
+   * {@link PslNamespace.entries} under their discriminator key (read them with
+   * {@link namespacePslExtensionBlocks}); this field holds the registry of
+   * descriptors that teach the parser how to read those blocks.
+   */
+  readonly pslBlockDescriptors?: AuthoringPslBlockDescriptorNamespace;
+  /**
+   * Codec lookup for validating `value`-kind extension block parameters.
+   * When provided alongside `pslBlockDescriptors`, the generic validator runs
+   * over every parsed extension block after the full AST is assembled,
+   * appending any diagnostics to the parse result. Absent or undefined means
+   * no codec validation runs; `ref` resolution still runs when namespace
+   * context is available (built from the assembled namespaces).
+   */
+  readonly codecLookup?: CodecLookup;
 }
 interface ParsePslDocumentResult {
   readonly ast: PslDocumentAst;
@@ -197,5 +269,5 @@ interface ParsePslDocumentResult {
   readonly ok: boolean;
 }
 //#endregion
-export { UNSPECIFIED_PSL_NAMESPACE_ID as A, PslNamespace as C, PslTypeConstructorCall as D, PslSpan as E, flatPslEnums as M, flatPslModels as N, PslTypesBlock as O, PslNamedTypeDeclaration as S, PslReferentialAction as T, PslField as _, PslAttributeNamedArgument as a, PslModel as b, PslCompositeType as c, PslDefaultValue as d, PslDiagnostic as f, PslEnumValue as g, PslEnum as h, PslAttributeArgument as i, flatPslCompositeTypes as j, PslUniqueConstraint as k, PslDefaultFunctionValue as l, PslDocumentAst as m, ParsePslDocumentResult as n, PslAttributePositionalArgument as o, PslDiagnosticCode as p, PslAttribute as r, PslAttributeTarget as s, ParsePslDocumentInput as t, PslDefaultLiteralValue as u, PslFieldAttribute as v, PslPosition as w, PslModelAttribute as x, PslIndexConstraint as y };
-//# sourceMappingURL=psl-ast-BDXL7iCg.d.mts.map
+export { flatPslCompositeTypes as A, PslNamespace as C, PslTypesBlock as D, PslTypeConstructorCall as E, namespacePslExtensionBlocks as F, flatPslModels as M, makePslNamespace as N, PslUniqueConstraint as O, makePslNamespaceEntries as P, PslNamedTypeDeclaration as S, PslReferentialAction as T, PslField as _, PslAttributeArgument as a, PslModel as b, PslAttributeTarget as c, PslDefaultLiteralValue as d, PslDefaultValue as f, PslEnumValue as g, PslEnum as h, PslAttribute as i, flatPslEnums as j, UNSPECIFIED_PSL_NAMESPACE_ID as k, PslCompositeType as l, PslDocumentAst as m, ParsePslDocumentInput as n, PslAttributeNamedArgument as o, PslDiagnostic as p, ParsePslDocumentResult as r, PslAttributePositionalArgument as s, BUILTIN_PSL_KIND_KEYS as t, PslDefaultFunctionValue as u, PslFieldAttribute as v, PslNamespaceEntry as w, PslModelAttribute as x, PslIndexConstraint as y };
+//# sourceMappingURL=psl-ast-Cn50B-UG.d.mts.map

package/dist/psl-ast-Cn50B-UG.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-ast-Cn50B-UG.d.mts","names":[],"sources":["../src/control/psl-ast.ts"],"mappings":"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"}

package/dist/psl-ast.d.mts

@@ -1,2 +1,37 @@
-import { A as UNSPECIFIED_PSL_NAMESPACE_ID, C as PslNamespace, D as PslTypeConstructorCall, E as PslSpan, M as flatPslEnums, N as flatPslModels, O as PslTypesBlock, S as PslNamedTypeDeclaration, T as PslReferentialAction, _ as PslField, a as PslAttributeNamedArgument, b as PslModel, c as PslCompositeType, d as PslDefaultValue, f as PslDiagnostic, g as PslEnumValue, h as PslEnum, i as PslAttributeArgument, j as flatPslCompositeTypes, k as PslUniqueConstraint, l as PslDefaultFunctionValue, m as PslDocumentAst, n as ParsePslDocumentResult, o as PslAttributePositionalArgument, p as PslDiagnosticCode, r as PslAttribute, s as PslAttributeTarget, t as ParsePslDocumentInput, u as PslDefaultLiteralValue, v as PslFieldAttribute, w as PslPosition, x as PslModelAttribute, y as PslIndexConstraint } from "./psl-ast-BDXL7iCg.mjs";
-export { ParsePslDocumentInput, ParsePslDocumentResult, PslAttribute, PslAttributeArgument, PslAttributeNamedArgument, PslAttributePositionalArgument, PslAttributeTarget, PslCompositeType, PslDefaultFunctionValue, PslDefaultLiteralValue, PslDefaultValue, PslDiagnostic, PslDiagnosticCode, PslDocumentAst, PslEnum, PslEnumValue, PslField, PslFieldAttribute, PslIndexConstraint, PslModel, PslModelAttribute, PslNamedTypeDeclaration, PslNamespace, PslPosition, PslReferentialAction, PslSpan, PslTypeConstructorCall, PslTypesBlock, PslUniqueConstraint, UNSPECIFIED_PSL_NAMESPACE_ID, flatPslCompositeTypes, flatPslEnums, flatPslModels };
+import { B as PslExtensionBlockParamOption, F as PslBlockParamRef, G as PslSpan, H as PslExtensionBlockParamScalarValue, I as PslBlockParamValue, L as PslDiagnosticCode, M as PslBlockParam, N as PslBlockParamList, P as PslBlockParamOption, R as PslExtensionBlock, U as PslExtensionBlockParamValue, V as PslExtensionBlockParamRef, W as PslPosition, m as AuthoringPslBlockDescriptorNamespace, p as AuthoringPslBlockDescriptor, z as PslExtensionBlockParamList } from "./framework-authoring-R0TYCkvG.mjs";
+import { c as CodecLookup } from "./codec-DCQAerzB.mjs";
+import { A as flatPslCompositeTypes, C as PslNamespace, D as PslTypesBlock, E as PslTypeConstructorCall, F as namespacePslExtensionBlocks, M as flatPslModels, N as makePslNamespace, O as PslUniqueConstraint, P as makePslNamespaceEntries, S as PslNamedTypeDeclaration, T as PslReferentialAction, _ as PslField, a as PslAttributeArgument, b as PslModel, c as PslAttributeTarget, d as PslDefaultLiteralValue, f as PslDefaultValue, g as PslEnumValue, h as PslEnum, i as PslAttribute, j as flatPslEnums, k as UNSPECIFIED_PSL_NAMESPACE_ID, l as PslCompositeType, m as PslDocumentAst, n as ParsePslDocumentInput, o as PslAttributeNamedArgument, p as PslDiagnostic, r as ParsePslDocumentResult, s as PslAttributePositionalArgument, t as BUILTIN_PSL_KIND_KEYS, u as PslDefaultFunctionValue, v as PslFieldAttribute, w as PslNamespaceEntry, x as PslModelAttribute, y as PslIndexConstraint } from "./psl-ast-Cn50B-UG.mjs";
+
+//#region src/control/psl-extension-block-validator.d.ts
+/**
+ * Context for ref resolution during extension-block validation.
+ *
+ * - `ownerNamespace` is the `PslNamespace` that contains the block being
+ *   validated. Used for `same-namespace` scope checks.
+ * - `allNamespaces` is every namespace in the document. Used for `same-space`
+ *   scope checks.
+ */
+interface ExtensionBlockRefResolutionContext {
+  readonly ownerNamespace: PslNamespace;
+  readonly allNamespaces: readonly PslNamespace[];
+}
+/**
+ * Validate a single parsed extension block against its descriptor.
+ *
+ * Returns an array of {@link PslDiagnostic} objects (possibly empty). The
+ * caller is responsible for threading `sourceId` into each returned diagnostic
+ * — the returned objects already have `sourceId` set from the `sourceId`
+ * parameter.
+ *
+ * @param node - The parsed block node produced by the generic framework parser.
+ * @param descriptor - The descriptor that claims this block's keyword.
+ * @param sourceId - The PSL source file identifier (threaded into diagnostics).
+ * @param codecLookup - Used to validate `value`-kind parameter literals via
+ *   `codecLookup.get(codecId)?.decodeJson(JSON.parse(raw))`.
+ * @param refCtx - Namespace context for `ref`-kind scope resolution. Required
+ *   when any descriptor parameter is `kind: 'ref'`; may be omitted if none are.
+ */
+declare function validateExtensionBlock(node: PslExtensionBlock, descriptor: AuthoringPslBlockDescriptor, sourceId: string, codecLookup: CodecLookup, refCtx?: ExtensionBlockRefResolutionContext): readonly PslDiagnostic[];
+//#endregion
+export { type AuthoringPslBlockDescriptorNamespace, BUILTIN_PSL_KIND_KEYS, type ExtensionBlockRefResolutionContext, ParsePslDocumentInput, ParsePslDocumentResult, PslAttribute, PslAttributeArgument, PslAttributeNamedArgument, PslAttributePositionalArgument, PslAttributeTarget, type PslBlockParam, type PslBlockParamList, type PslBlockParamOption, type PslBlockParamRef, type PslBlockParamValue, PslCompositeType, PslDefaultFunctionValue, PslDefaultLiteralValue, PslDefaultValue, PslDiagnostic, type PslDiagnosticCode, PslDocumentAst, PslEnum, PslEnumValue, type PslExtensionBlock, type PslExtensionBlockParamList, type PslExtensionBlockParamOption, type PslExtensionBlockParamRef, type PslExtensionBlockParamScalarValue, type PslExtensionBlockParamValue, PslField, PslFieldAttribute, PslIndexConstraint, PslModel, PslModelAttribute, PslNamedTypeDeclaration, PslNamespace, PslNamespaceEntry, type PslPosition, PslReferentialAction, type PslSpan, PslTypeConstructorCall, PslTypesBlock, PslUniqueConstraint, UNSPECIFIED_PSL_NAMESPACE_ID, flatPslCompositeTypes, flatPslEnums, flatPslModels, makePslNamespace, makePslNamespaceEntries, namespacePslExtensionBlocks, validateExtensionBlock };
+//# sourceMappingURL=psl-ast.d.mts.map

package/dist/psl-ast.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-ast.d.mts","names":[],"sources":["../src/control/psl-extension-block-validator.ts"],"mappings":";;;;;;;;;;;;;UA2EiB,kCAAA;EAAA,SACN,cAAA,EAAgB,YAAA;EAAA,SAChB,aAAA,WAAwB,YAAY;AAAA;;;;;;;;;;;;;;;;;iBAmB/B,sBAAA,CACd,IAAA,EAAM,iBAAA,EACN,UAAA,EAAY,2BAAA,EACZ,QAAA,UACA,WAAA,EAAa,WAAA,EACb,MAAA,GAAS,kCAAA,YACC,aAAA"}

package/dist/psl-ast.mjs

@@ -1,3 +1,4 @@
+import { blindCast } from "@prisma-next/utils/casts";
 //#region src/control/psl-ast.ts
 /**
 * Name of the synthesised namespace bucket the framework parser uses for
@@ -13,25 +14,242 @@
 */
 const UNSPECIFIED_PSL_NAMESPACE_ID = "__unspecified__";
 /**
+* Stores `entries`; exposes `models`/`enums`/`compositeTypes` as getters over
+* it. The getters are prototype members (non-enumerable), so spreading or
+* `JSON.stringify`-ing a namespace copies only `entries`, never a duplicate view.
+*/
+var PslNamespaceNode = class {
+	kind = "namespace";
+	name;
+	entries;
+	span;
+	constructor(init) {
+		this.name = init.name;
+		this.entries = init.entries;
+		this.span = init.span;
+		Object.freeze(this);
+	}
+	get models() {
+		return blindCast(Object.values(this.entries["model"] ?? {}));
+	}
+	get enums() {
+		return blindCast(Object.values(this.entries["enum"] ?? {}));
+	}
+	get compositeTypes() {
+		return blindCast(Object.values(this.entries["compositeType"] ?? {}));
+	}
+};
+/** Constructs a {@link PslNamespace}. Use this, never a namespace literal — the accessors must derive from `entries`. */
+function makePslNamespace(init) {
+	return new PslNamespaceNode(init);
+}
+/**
+* Builds the frozen `entries[kind][name]` container from per-kind arrays.
+* Built-ins key on their PSL keyword; extension blocks key on their `kind`
+* discriminator. Call this rather than hand-building the literal.
+*/
+function makePslNamespaceEntries(models, enums, compositeTypes, extensionBlocks) {
+	const container = {};
+	if (models.length > 0) {
+		const map = {};
+		for (const m of models) map[m.name] = m;
+		container["model"] = Object.freeze(map);
+	}
+	if (enums.length > 0) {
+		const map = {};
+		for (const e of enums) map[e.name] = e;
+		container["enum"] = Object.freeze(map);
+	}
+	if (compositeTypes.length > 0) {
+		const map = {};
+		for (const ct of compositeTypes) map[ct.name] = ct;
+		container["compositeType"] = Object.freeze(map);
+	}
+	for (const block of extensionBlocks) {
+		const existing = container[block.kind];
+		const newMap = existing ? blindCast({ ...existing }) : {};
+		newMap[block.name] = block;
+		container[block.kind] = Object.freeze(newMap);
+	}
+	return Object.freeze(container);
+}
+/**
 * Returns all models from every namespace in document order. Convenience
 * for consumers that don't (yet) need namespace-awareness.
 */
 function flatPslModels(ast) {
-	return ast.namespaces.flatMap((ns) => ns.models);
+	return ast.namespaces.flatMap((ns) => blindCast(Object.values(ns.entries["model"] ?? {})));
 }
 /**
 * Returns all enums from every namespace in document order.
 */
 function flatPslEnums(ast) {
-	return ast.namespaces.flatMap((ns) => ns.enums);
+	return ast.namespaces.flatMap((ns) => blindCast(Object.values(ns.entries["enum"] ?? {})));
 }
 /**
 * Returns all composite types from every namespace in document order.
 */
 function flatPslCompositeTypes(ast) {
-	return ast.namespaces.flatMap((ns) => ns.compositeTypes);
+	return ast.namespaces.flatMap((ns) => blindCast(Object.values(ns.entries["compositeType"] ?? {})));
+}
+/**
+* The set of `entries` kind keys that the framework parser reserves for
+* built-in PSL entity kinds. Any own-enumerable key on `PslNamespace.entries`
+* that is **not** in this set was contributed by an extension-block descriptor.
+*
+* Built-in keys match the PSL keyword used on each block type:
+* `'model'`, `'enum'`, `'compositeType'`.
+*/
+const BUILTIN_PSL_KIND_KEYS = new Set([
+	"model",
+	"enum",
+	"compositeType"
+]);
+/**
+* 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
+* (`'model'`, `'enum'`, `'compositeType'`). All remaining kind maps contain
+* only `PslExtensionBlock` nodes by construction (see `makePslNamespaceEntries`).
+*/
+function namespacePslExtensionBlocks(ns) {
+	const result = [];
+	for (const [kindKey, kindMap] of Object.entries(ns.entries)) {
+		if (BUILTIN_PSL_KIND_KEYS.has(kindKey)) continue;
+		for (const entry of Object.values(kindMap)) result.push(blindCast(entry));
+	}
+	return result;
+}
+//#endregion
+//#region src/control/psl-extension-block-validator.ts
+/**
+* Validate a single parsed extension block against its descriptor.
+*
+* Returns an array of {@link PslDiagnostic} objects (possibly empty). The
+* caller is responsible for threading `sourceId` into each returned diagnostic
+* — the returned objects already have `sourceId` set from the `sourceId`
+* parameter.
+*
+* @param node - The parsed block node produced by the generic framework parser.
+* @param descriptor - The descriptor that claims this block's keyword.
+* @param sourceId - The PSL source file identifier (threaded into diagnostics).
+* @param codecLookup - Used to validate `value`-kind parameter literals via
+*   `codecLookup.get(codecId)?.decodeJson(JSON.parse(raw))`.
+* @param refCtx - Namespace context for `ref`-kind scope resolution. Required
+*   when any descriptor parameter is `kind: 'ref'`; may be omitted if none are.
+*/
+function validateExtensionBlock(node, descriptor, sourceId, codecLookup, refCtx) {
+	const diagnostics = [];
+	const descriptorKeys = new Set(Object.keys(descriptor.parameters));
+	const nodeKeys = new Set(Object.keys(node.parameters));
+	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
+		});
+	}
+	for (const [key, param] of Object.entries(descriptor.parameters)) if (param.required === true && !nodeKeys.has(key)) diagnostics.push({
+		code: "PSL_EXTENSION_MISSING_REQUIRED_PARAMETER",
+		message: `Required parameter "${key}" is missing from "${descriptor.keyword}" block "${node.name}".`,
+		sourceId,
+		span: node.span
+	});
+	for (const [key, param] of Object.entries(descriptor.parameters)) {
+		const captured = node.parameters[key];
+		if (captured === void 0) continue;
+		validateParam(node, descriptor, key, param, captured, sourceId, codecLookup, refCtx, diagnostics);
+	}
+	return diagnostics;
+}
+function validateParam(node, descriptor, key, param, captured, sourceId, codecLookup, refCtx, diagnostics) {
+	switch (param.kind) {
+		case "option":
+			if (captured.kind !== "option") return;
+			if (!param.values.includes(captured.token)) diagnostics.push({
+				code: "PSL_EXTENSION_OPTION_OUT_OF_SET",
+				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(", ")}.`,
+				sourceId,
+				span: captured.span
+			});
+			return;
+		case "value": {
+			if (captured.kind !== "value") return;
+			const codec = codecLookup.get(param.codecId);
+			if (codec === void 0) {
+				diagnostics.push({
+					code: "PSL_EXTENSION_INVALID_VALUE",
+					message: `Parameter "${key}" in "${descriptor.keyword}" block "${node.name}" references unknown codec "${param.codecId}".`,
+					sourceId,
+					span: captured.span
+				});
+				return;
+			}
+			let jsonValue;
+			try {
+				jsonValue = JSON.parse(captured.raw);
+			} catch {
+				diagnostics.push({
+					code: "PSL_EXTENSION_INVALID_VALUE",
+					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}`,
+					sourceId,
+					span: captured.span
+				});
+				return;
+			}
+			try {
+				codec.decodeJson(blindCast(jsonValue));
+			} catch (err) {
+				const reason = err instanceof Error ? err.message : String(err);
+				diagnostics.push({
+					code: "PSL_EXTENSION_INVALID_VALUE",
+					message: `Parameter "${key}" in "${descriptor.keyword}" block "${node.name}" was rejected by codec "${param.codecId}": ${reason}`,
+					sourceId,
+					span: captured.span
+				});
+			}
+			return;
+		}
+		case "ref":
+			if (captured.kind !== "ref") return;
+			validateRef(node, descriptor, key, param, captured.identifier, captured.span, sourceId, refCtx, diagnostics);
+			return;
+		case "list":
+			if (captured.kind !== "list") return;
+			for (const item of captured.items) validateParam(node, descriptor, key, param.of, item, sourceId, codecLookup, refCtx, diagnostics);
+			return;
+	}
+}
+function validateRef(node, descriptor, key, param, identifier, span, sourceId, refCtx, diagnostics) {
+	if (param.scope === "cross-space") return;
+	if (refCtx === void 0) return;
+	const namespacesToSearch = param.scope === "same-namespace" ? [refCtx.ownerNamespace] : refCtx.allNamespaces;
+	if (!resolveEntityInNamespaces(identifier, param.refKind, namespacesToSearch)) {
+		const scopeLabel = param.scope === "same-namespace" ? "the same namespace" : "any namespace in the schema";
+		diagnostics.push({
+			code: "PSL_EXTENSION_UNRESOLVED_REF",
+			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}.`,
+			sourceId,
+			span
+		});
+	}
+}
+/**
+* True if an entity named `name` of kind `refKind` exists in any of the given
+* namespaces. Built-in and extension kinds resolve the same way, through
+* `entries[refKind]`.
+*/
+function resolveEntityInNamespaces(name, refKind, namespaces) {
+	for (const ns of namespaces) {
+		const kindMap = ns.entries[refKind];
+		if (kindMap !== void 0 && Object.hasOwn(kindMap, name)) return true;
+	}
+	return false;
 }
 //#endregion
-export { UNSPECIFIED_PSL_NAMESPACE_ID, flatPslCompositeTypes, flatPslEnums, flatPslModels };
+export { BUILTIN_PSL_KIND_KEYS, UNSPECIFIED_PSL_NAMESPACE_ID, flatPslCompositeTypes, flatPslEnums, flatPslModels, makePslNamespace, makePslNamespaceEntries, namespacePslExtensionBlocks, validateExtensionBlock };
 
 //# sourceMappingURL=psl-ast.mjs.map