@prisma-next/framework-components 0.12.0-dev.61 → 0.12.0-dev.62

package/dist/framework-authoring-Cyde8zSN.d.mts

@@ -0,0 +1,380 @@
+import { ColumnDefault, ExecutionMutationDefaultPhases } from "@prisma-next/contract/types";
+import { Type } from "arktype";
+
+//#region src/shared/psl-extension-block.d.ts
+/**
+ * Shape-only types for the PSL source-position primitives, diagnostic
+ * codes, extension-block descriptor vocabulary, and the uniform
+ * extension-block AST node base.
+ *
+ * These live in the shared plane so an extension's authoring descriptor
+ * (`AuthoringPslBlockDescriptor` in `framework-authoring`) can reference
+ * them without crossing the shared → migration-plane boundary. The
+ * migration-plane `psl-ast.ts` re-exports everything here for consumers
+ * that import PSL AST types from the control entrypoint.
+ */
+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'
+/**
+ * A malformed line inside an extension-contributed top-level block body, or
+ * a structurally invalid element inside a `list` parameter value.
+ *
+ * Replaces the overloaded `PSL_UNSUPPORTED_TOP_LEVEL_BLOCK` code that the
+ * generic framework parser previously used for these two parse-error sites
+ * inside extension blocks — keeping `PSL_UNSUPPORTED_TOP_LEVEL_BLOCK` for
+ * its original meaning (an unknown keyword at the top level) and giving
+ * extension-block parse errors their own code.
+ */
+| 'PSL_INVALID_EXTENSION_BLOCK_MEMBER'
+/**
+ * An unknown parameter key in an extension-contributed block — a key present
+ * in the source block but absent from the descriptor's `parameters` map.
+ */
+| 'PSL_EXTENSION_UNKNOWN_PARAMETER'
+/**
+ * A required parameter declared in the descriptor is absent from the parsed block.
+ */
+| 'PSL_EXTENSION_MISSING_REQUIRED_PARAMETER'
+/**
+ * An `option`-kind parameter value is not one of the allowed tokens listed
+ * in the descriptor's `values` array.
+ */
+| 'PSL_EXTENSION_OPTION_OUT_OF_SET'
+/**
+ * A `value`-kind parameter's raw text is not a valid JSON literal, or the
+ * parsed JSON value was rejected by the codec's `decodeJson` method, or the
+ * codec id is not registered in the lookup.
+ */
+| 'PSL_EXTENSION_INVALID_VALUE'
+/**
+ * A `ref`-kind parameter identifier does not resolve to a declared entity of
+ * the required `refKind` within the declared scope.
+ */
+| 'PSL_EXTENSION_UNRESOLVED_REF';
+/**
+ * Descriptor vocabulary for a single parameter on a declared block.
+ *
+ * Four kinds:
+ * - `ref` — the parameter value is an identifier that must resolve to a
+ *   declared entity of `refKind` within the declared `scope`.
+ * - `value` — the parameter value is a PSL literal parsed and printed
+ *   through the codec identified by `codecId`.
+ * - `option` — the parameter value is one of the literal tokens in `values`.
+ *   Not a codec; not persisted data. A closed authoring-time constraint only.
+ * - `list` — a bracketed list whose elements each match the `of` descriptor.
+ */
+type PslBlockParam = PslBlockParamRef | PslBlockParamValue | PslBlockParamOption | PslBlockParamList;
+interface PslBlockParamRef {
+  readonly kind: 'ref';
+  readonly refKind: string;
+  readonly scope: 'same-namespace' | 'same-space' | 'cross-space';
+  readonly required?: boolean;
+}
+interface PslBlockParamValue {
+  readonly kind: 'value';
+  readonly codecId: string;
+  readonly required?: boolean;
+}
+interface PslBlockParamOption {
+  readonly kind: 'option';
+  readonly values: readonly string[];
+  readonly required?: boolean;
+}
+interface PslBlockParamList {
+  readonly kind: 'list';
+  readonly of: PslBlockParam;
+  readonly required?: boolean;
+}
+/**
+ * The parsed representation of a single parameter value on a uniform
+ * extension-block AST node. Mirrors the `PslBlockParam` descriptor
+ * vocabulary:
+ *
+ * - `ref`    → `PslExtensionBlockParamRef` — a raw identifier string
+ *   (resolution runs in the validator, not the parser).
+ * - `value`  → `PslExtensionBlockParamValue` — a raw PSL literal string
+ *   (codec validation runs in the validator).
+ * - `option` → `PslExtensionBlockParamOption` — the chosen token.
+ * - `list`   → `PslExtensionBlockParamList` — ordered list of the above.
+ *
+ * These shapes are intentionally minimal. The validator and lowering refine
+ * and consume them; the generic framework parser produces them.
+ */
+type PslExtensionBlockParamValue = PslExtensionBlockParamRef | PslExtensionBlockParamScalarValue | PslExtensionBlockParamOption | PslExtensionBlockParamList;
+interface PslExtensionBlockParamRef {
+  readonly kind: 'ref';
+  readonly identifier: string;
+  readonly span: PslSpan;
+}
+interface PslExtensionBlockParamScalarValue {
+  readonly kind: 'value';
+  readonly raw: string;
+  readonly span: PslSpan;
+}
+interface PslExtensionBlockParamOption {
+  readonly kind: 'option';
+  readonly token: string;
+  readonly span: PslSpan;
+}
+interface PslExtensionBlockParamList {
+  readonly kind: 'list';
+  readonly items: readonly PslExtensionBlockParamValue[];
+  readonly span: PslSpan;
+}
+/**
+ * Base shape for a uniform extension-contributed top-level PSL block
+ * node, as produced by the generic framework parser and consumed by the
+ * validator and lowering factory.
+ *
+ * - `kind` is the routing discriminant, equal to the descriptor's
+ *   `discriminator`. The framework parser sets this to
+ *   `descriptor.discriminator` for every block it parses.
+ * - `name` is the block's declared name (the identifier after the keyword).
+ * - `parameters` is the descriptor-driven parameter map. Keys are
+ *   parameter names from the descriptor; values are the parsed parameter
+ *   representations. Only parameters present in the source are included
+ *   — absence of a required parameter is a validator concern, not a
+ *   parser concern.
+ * - `span` covers the full block from keyword to closing brace.
+ */
+interface PslExtensionBlock {
+  readonly kind: string;
+  readonly name: string;
+  readonly parameters: Record<string, PslExtensionBlockParamValue>;
+  readonly span: PslSpan;
+}
+//#endregion
+//#region src/shared/framework-authoring.d.ts
+type AuthoringArgRef = {
+  readonly kind: 'arg';
+  readonly index: number;
+  readonly path?: readonly string[];
+  readonly default?: AuthoringTemplateValue;
+};
+type AuthoringTemplateValue = string | number | boolean | null | AuthoringArgRef | readonly AuthoringTemplateValue[] | {
+  readonly [key: string]: AuthoringTemplateValue;
+};
+interface AuthoringArgumentDescriptorCommon {
+  readonly name?: string;
+  readonly optional?: boolean;
+}
+type AuthoringArgumentDescriptor = AuthoringArgumentDescriptorCommon & ({
+  readonly kind: 'string';
+} | {
+  readonly kind: 'boolean';
+} | {
+  readonly kind: 'number';
+  readonly integer?: boolean;
+  readonly minimum?: number;
+  readonly maximum?: number;
+} | {
+  readonly kind: 'stringArray';
+} | {
+  readonly kind: 'object';
+  readonly properties: Record<string, AuthoringArgumentDescriptor>;
+});
+interface AuthoringStorageTypeTemplate {
+  readonly codecId: string;
+  readonly nativeType: AuthoringTemplateValue;
+  readonly typeParams?: Record<string, AuthoringTemplateValue>;
+}
+interface AuthoringTypeConstructorDescriptor {
+  readonly kind: 'typeConstructor';
+  readonly args?: readonly AuthoringArgumentDescriptor[];
+  readonly output: AuthoringStorageTypeTemplate;
+}
+interface AuthoringColumnDefaultTemplateLiteral {
+  readonly kind: 'literal';
+  readonly value: AuthoringTemplateValue;
+}
+interface AuthoringColumnDefaultTemplateFunction {
+  readonly kind: 'function';
+  readonly expression: AuthoringTemplateValue;
+}
+type AuthoringColumnDefaultTemplate = AuthoringColumnDefaultTemplateLiteral | AuthoringColumnDefaultTemplateFunction;
+interface AuthoringExecutionDefaultsTemplate {
+  readonly onCreate?: AuthoringTemplateValue;
+  readonly onUpdate?: AuthoringTemplateValue;
+}
+interface AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {
+  readonly nullable?: boolean;
+  readonly default?: AuthoringColumnDefaultTemplate;
+  readonly executionDefaults?: AuthoringExecutionDefaultsTemplate;
+  readonly id?: boolean;
+  readonly unique?: boolean;
+}
+interface AuthoringFieldPresetDescriptor {
+  readonly kind: 'fieldPreset';
+  readonly args?: readonly AuthoringArgumentDescriptor[];
+  readonly output: AuthoringFieldPresetOutput;
+}
+type AuthoringTypeNamespace = {
+  readonly [name: string]: AuthoringTypeConstructorDescriptor | AuthoringTypeNamespace;
+};
+type AuthoringFieldNamespace = {
+  readonly [name: string]: AuthoringFieldPresetDescriptor | AuthoringFieldNamespace;
+};
+/**
+ * Context surfaced to entity-type factories at call time. Currently a
+ * placeholder — sharpened as concrete consumers (enum, namespace, …)
+ * discover what the factory actually needs to read (codec lookup,
+ * namespace registry, …).
+ */
+interface AuthoringEntityContext {
+  readonly family: string;
+  readonly target: string;
+}
+interface AuthoringEntityTypeTemplateOutput {
+  readonly template: AuthoringTemplateValue;
+}
+/**
+ * Default `Input = never` is load-bearing for pack-bag-driven type
+ * narrowing. Factory parameter positions are contravariant, so a pack
+ * literal declaring `factory: (input: DemoEntityInput) => DemoEntity`
+ * is only assignable to the base descriptor's factory shape if the
+ * base's input is `never` (the bottom of the contravariant position).
+ * The concrete input/output types are recovered at the helper-derivation
+ * site via `EntityHelperFunction<Descriptor>`'s conditional inference,
+ * which reads them from the pack's `as const` literal factory signature
+ * — the base widening does not erase the literal because `satisfies`
+ * does not widen the declared type.
+ */
+interface AuthoringEntityTypeFactoryOutput<Input = never, Output = unknown> {
+  readonly factory: (input: Input, ctx: AuthoringEntityContext) => Output;
+}
+interface AuthoringEntityTypeDescriptor<Input = never, Output = unknown> {
+  readonly kind: 'entity';
+  readonly discriminator: string;
+  readonly args?: readonly AuthoringArgumentDescriptor[];
+  readonly output: AuthoringEntityTypeTemplateOutput | AuthoringEntityTypeFactoryOutput<Input, Output>;
+  /**
+   * arktype schema fragment for one entry whose envelope `kind` matches
+   * this descriptor's {@link discriminator}. The family validator composes
+   * contributed fragments into the per-namespace entry schema at
+   * validator construction time so the structural check covers
+   * pack-introduced kinds without the family core hard-coding the schema.
+   *
+   * Hydration uses {@link AuthoringEntityTypeFactoryOutput.factory}
+   * directly — the wire shape conforms structurally to the factory's
+   * `Input` after `validatorSchema` validates it.
+   */
+  readonly validatorSchema?: Type<unknown>;
+}
+type AuthoringEntityTypeNamespace = {
+  readonly [name: string]: AuthoringEntityTypeDescriptor | AuthoringEntityTypeNamespace;
+};
+/**
+ * Declarative descriptor for an extension-contributed top-level PSL block.
+ *
+ * An extension registers one of these per keyword it contributes. The
+ * framework owns the generic parser, validator, and printer — no
+ * parsing or printing code runs from the extension.
+ *
+ * - `keyword` is the PSL top-level identifier this descriptor claims
+ *   (`policy_select`, `role`, …).
+ * - `discriminator` is the routing key used by the printer dispatch and
+ *   the `entityTypes` lowering factory lookup. Convention:
+ *   `<target-or-family>-<kind>` (`postgres-policy-select`).
+ * - `name.required` declares whether the block must have a name token
+ *   after the keyword. Currently always `true` — anonymous blocks are
+ *   not part of the closed-grammar premise — but the field is explicit
+ *   so the type can evolve without a breaking change.
+ * - `parameters` maps parameter names to their value-kind descriptors
+ *   (`ref` / `value` / `option` / `list`). The generic parser and
+ *   validator interpret these; the extension supplies no parser or
+ *   printer function.
+ */
+interface AuthoringPslBlockDescriptor {
+  readonly kind: 'pslBlock';
+  readonly keyword: string;
+  readonly discriminator: string;
+  readonly name: {
+    readonly required: boolean;
+  };
+  readonly parameters: Record<string, PslBlockParam>;
+}
+type AuthoringPslBlockDescriptorNamespace = {
+  readonly [name: string]: AuthoringPslBlockDescriptor | AuthoringPslBlockDescriptorNamespace;
+};
+interface AuthoringContributions {
+  readonly type?: AuthoringTypeNamespace;
+  readonly field?: AuthoringFieldNamespace;
+  readonly entityTypes?: AuthoringEntityTypeNamespace;
+  /**
+   * Registry of declarative block descriptors this contribution registers,
+   * keyed by arbitrary path segments. Each leaf is an
+   * {@link AuthoringPslBlockDescriptor} that claims a PSL top-level keyword.
+   * The framework owns the generic parser, validator, and printer; the
+   * contribution supplies only these declarative descriptors.
+   *
+   * Contrast with {@link PslNamespace.extensionBlocks}: that field holds
+   * the parsed block nodes in a namespace; this field holds the registry
+   * of descriptors that teach the parser how to read those blocks.
+   */
+  readonly pslBlockDescriptors?: AuthoringPslBlockDescriptorNamespace;
+}
+declare function isAuthoringArgRef(value: unknown): value is AuthoringArgRef;
+declare function isAuthoringTypeConstructorDescriptor(value: unknown): value is AuthoringTypeConstructorDescriptor;
+declare function isAuthoringFieldPresetDescriptor(value: unknown): value is AuthoringFieldPresetDescriptor;
+declare function isAuthoringEntityTypeDescriptor(value: unknown): value is AuthoringEntityTypeDescriptor;
+declare function isAuthoringPslBlockDescriptor(value: unknown): value is AuthoringPslBlockDescriptor;
+/**
+ * Returns true when `namespace` is a non-leaf key in `contributions.field`.
+ *
+ * `AuthoringFieldNamespace` permits a leaf descriptor at any depth — including
+ * the root — so a top-level `field: { Foo: { kind: 'fieldPreset', ... } }`
+ * registration must NOT be treated as a "namespace" with sub-paths. Callers
+ * use this predicate to gate dot-namespaced lookups (e.g. PSL `@Foo.bar`).
+ */
+declare function hasRegisteredFieldNamespace(contributions: AuthoringContributions | undefined, namespace: string): boolean;
+/**
+ * Merges `source` into `target` recursively at the descriptor-namespace
+ * level. `leafGuard` decides which values are descriptors (terminal
+ * merge points; same-path registrations across components are reported
+ * as duplicates) versus sub-namespaces (recursion targets).
+ *
+ * Path segments are validated against prototype-pollution names
+ * (`__proto__`, `constructor`, `prototype`). A value that is neither a
+ * recognized leaf nor a plain object — e.g. a malformed descriptor
+ * where the canonical leaf guard rejected it for missing `output` —
+ * is reported as an invalid contribution rather than recursed into,
+ * which would either silently mangle state or infinite-loop on
+ * primitive properties.
+ *
+ * Within-registry duplicate detection is this walker's job;
+ * cross-registry detection runs separately via
+ * `assertNoCrossRegistryCollisions` after merging completes.
+ */
+declare function mergeAuthoringNamespaces(target: Record<string, unknown>, source: Record<string, unknown>, path: readonly string[], leafGuard: (value: unknown) => boolean, label: string): void;
+declare function assertNoCrossRegistryCollisions(typeNamespace: AuthoringTypeNamespace, fieldNamespace: AuthoringFieldNamespace, entityTypeNamespace?: AuthoringEntityTypeNamespace, pslBlockNamespace?: AuthoringPslBlockDescriptorNamespace): void;
+declare function resolveAuthoringTemplateValue(template: AuthoringTemplateValue, args: readonly unknown[]): unknown;
+declare function validateAuthoringHelperArguments(helperPath: string, descriptors: readonly AuthoringArgumentDescriptor[] | undefined, args: readonly unknown[]): void;
+declare function instantiateAuthoringTypeConstructor(descriptor: AuthoringTypeConstructorDescriptor, args: readonly unknown[]): {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+};
+declare function instantiateAuthoringEntityType(helperPath: string, descriptor: AuthoringEntityTypeDescriptor, args: readonly unknown[], ctx: AuthoringEntityContext): unknown;
+declare function instantiateAuthoringFieldPreset(descriptor: AuthoringFieldPresetDescriptor, args: readonly unknown[]): {
+  readonly descriptor: {
+    readonly codecId: string;
+    readonly nativeType: string;
+    readonly typeParams?: Record<string, unknown>;
+  };
+  readonly nullable: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+  readonly id: boolean;
+  readonly unique: boolean;
+};
+//#endregion
+export { resolveAuthoringTemplateValue as A, PslExtensionBlockParamOption as B, instantiateAuthoringTypeConstructor as C, isAuthoringPslBlockDescriptor as D, isAuthoringFieldPresetDescriptor as E, PslBlockParamRef as F, PslSpan as G, PslExtensionBlockParamScalarValue as H, PslBlockParamValue as I, PslDiagnosticCode as L, PslBlockParam as M, PslBlockParamList as N, isAuthoringTypeConstructorDescriptor as O, PslBlockParamOption as P, PslExtensionBlock as R, instantiateAuthoringFieldPreset as S, isAuthoringEntityTypeDescriptor as T, PslExtensionBlockParamValue as U, PslExtensionBlockParamRef as V, PslPosition as W, AuthoringTypeConstructorDescriptor as _, AuthoringEntityContext as a, hasRegisteredFieldNamespace as b, AuthoringEntityTypeNamespace as c, AuthoringFieldPresetDescriptor as d, AuthoringFieldPresetOutput as f, AuthoringTemplateValue as g, AuthoringStorageTypeTemplate as h, AuthoringContributions as i, validateAuthoringHelperArguments as j, mergeAuthoringNamespaces as k, AuthoringEntityTypeTemplateOutput as l, AuthoringPslBlockDescriptorNamespace as m, AuthoringArgumentDescriptor as n, AuthoringEntityTypeDescriptor as o, AuthoringPslBlockDescriptor as p, AuthoringColumnDefaultTemplate as r, AuthoringEntityTypeFactoryOutput as s, AuthoringArgRef as t, AuthoringFieldNamespace as u, AuthoringTypeNamespace as v, isAuthoringArgRef as w, instantiateAuthoringEntityType as x, assertNoCrossRegistryCollisions as y, PslExtensionBlockParamList as z };
+//# sourceMappingURL=framework-authoring-Cyde8zSN.d.mts.map

package/dist/framework-authoring-Cyde8zSN.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-authoring-Cyde8zSN.d.mts","names":[],"sources":["../src/shared/psl-extension-block.ts","../src/shared/framework-authoring.ts"],"mappings":";;;;;;;;AAYA;;;;;;;UAAiB,WAAA;EAAA,SACN,MAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;AAAA;AAAA,UAGM,OAAA;EAAA,SACN,KAAA,EAAO,WAAA;EAAA,SACP,GAAA,EAAK,WAAW;AAAA;AAAA,KAGf,iBAAA;;AAHe;AAG3B;;;;AAA6B;AA+D7B;;;;;;;;;;;;;;AAIqB;AAErB;;;;;;;;;AAImB;AAGnB;;;AAHmB;;;;;AAMA;AAGnB;;;;;;;KAnBY,aAAA,GACR,gBAAA,GACA,kBAAA,GACA,mBAAA,GACA,iBAAA;AAAA,UAEa,gBAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,KAAA;EAAA,SACA,QAAA;AAAA;AAAA,UAGM,kBAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;AAAA;AAAA,UAGM,mBAAA;EAAA,SACN,IAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA;AAAA;AAAA,UAGM,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,aAAa;EAAA,SACjB,QAAA;AAAA;;;;;AAsBmB;AAE9B;;;;;;;;;AAGwB;KATZ,2BAAA,GACR,yBAAA,GACA,iCAAA,GACA,4BAAA,GACA,0BAAA;AAAA,UAEa,yBAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA;EAAA,SACA,IAAA,EAAM,OAAO;AAAA;AAAA,UAGP,iCAAA;EAAA,SACN,IAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA,EAAM,OAAO;AAAA;AAAA,UAGP,4BAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA;EAAA,SACA,IAAA,EAAM,OAAO;AAAA;AAAA,UAGP,0BAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA,WAAgB,2BAAA;EAAA,SAChB,IAAA,EAAM,OAAO;AAAA;;;;;;;;;;AAAA;AAmBxB;;;;;;UAAiB,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA;EAAA,SACA,UAAA,EAAY,MAAA,SAAe,2BAAA;EAAA,SAC3B,IAAA,EAAM,OAAA;AAAA;;;KCxKL,eAAA;EAAA,SACD,IAAA;EAAA,SACA,KAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,GAAU,sBAAsB;AAAA;AAAA,KAG/B,sBAAA,sCAKR,eAAA,YACS,sBAAA;EAAA,UACG,GAAA,WAAc,sBAAA;AAAA;AAAA,UAEpB,iCAAA;EAAA,SACC,IAAA;EAAA,SACA,QAAQ;AAAA;AAAA,KAGP,2BAAA,GAA8B,iCAAA;EAAA,SAEzB,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;AAAA;EAAA,SAEA,IAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SACA,UAAA,EAAY,MAAA,SAAe,2BAAA;AAAA;AAAA,UAI3B,4BAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA,EAAY,sBAAA;EAAA,SACZ,UAAA,GAAa,MAAA,SAAe,sBAAA;AAAA;AAAA,UAGtB,kCAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA,YAAgB,2BAAA;EAAA,SAChB,MAAA,EAAQ,4BAA4B;AAAA;AAAA,UAG9B,qCAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA,EAAO,sBAAsB;AAAA;AAAA,UAGvB,sCAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA,EAAY,sBAAsB;AAAA;AAAA,KAGjC,8BAAA,GACR,qCAAA,GACA,sCAAsC;AAAA,UAEzB,kCAAA;EAAA,SACN,QAAA,GAAW,sBAAA;EAAA,SACX,QAAA,GAAW,sBAAsB;AAAA;AAAA,UAG3B,0BAAA,SAAmC,4BAAA;EAAA,SACzC,QAAA;EAAA,SACA,OAAA,GAAU,8BAAA;EAAA,SACV,iBAAA,GAAoB,kCAAA;EAAA,SACpB,EAAA;EAAA,SACA,MAAA;AAAA;AAAA,UAGM,8BAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA,YAAgB,2BAAA;EAAA,SAChB,MAAA,EAAQ,0BAA0B;AAAA;AAAA,KAGjC,sBAAA;EAAA,UACA,IAAA,WAAe,kCAAA,GAAqC,sBAAsB;AAAA;AAAA,KAG1E,uBAAA;EAAA,UACA,IAAA,WAAe,8BAAA,GAAiC,uBAAuB;AAAA;;;;;;;UASlE,sBAAA;EAAA,SACN,MAAA;EAAA,SACA,MAAM;AAAA;AAAA,UAGA,iCAAA;EAAA,SACN,QAAA,EAAU,sBAAsB;AAAA;;;;;;;;;;;ADmBb;AAE9B;UCNiB,gCAAA;EAAA,SACN,OAAA,GAAU,KAAA,EAAO,KAAA,EAAO,GAAA,EAAK,sBAAA,KAA2B,MAAA;AAAA;AAAA,UAGlD,6BAAA;EAAA,SACN,IAAA;EAAA,SACA,aAAA;EAAA,SACA,IAAA,YAAgB,2BAAA;EAAA,SAChB,MAAA,EACL,iCAAA,GACA,gCAAA,CAAiC,KAAA,EAAO,MAAA;EDDtB;AAGxB;;;;;;;;;AAGwB;EANA,SCab,eAAA,GAAkB,IAAA;AAAA;AAAA,KAGjB,4BAAA;EAAA,UACA,IAAA,WAAe,6BAAA,GAAgC,4BAA4B;AAAA;;;;;ADL/D;AAGxB;;;;;;;;;;AAGwB;AAmBxB;;;;;UCIiB,2BAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,aAAA;EAAA,SACA,IAAA;IAAA,SAAiB,QAAA;EAAA;EAAA,SACjB,UAAA,EAAY,MAAM,SAAS,aAAA;AAAA;AAAA,KAG1B,oCAAA;EAAA,UACA,IAAA,WAAe,2BAAA,GAA8B,oCAAoC;AAAA;AAAA,UAG5E,sBAAA;EAAA,SACN,IAAA,GAAO,sBAAA;EAAA,SACP,KAAA,GAAQ,uBAAA;EAAA,SACR,WAAA,GAAc,4BAAA;EAvLE;;;;;;;;;AAIgB;AAG3C;EAP2B,SAmMhB,mBAAA,GAAsB,oCAAA;AAAA;AAAA,iBAGjB,iBAAA,CAAkB,KAAA,YAAiB,KAAA,IAAS,eAAe;AAAA,iBAkB3D,oCAAA,CACd,KAAA,YACC,KAAA,IAAS,kCAAkC;AAAA,iBAU9B,gCAAA,CACd,KAAA,YACC,KAAA,IAAS,8BAA8B;AAAA,iBAU1B,+BAAA,CACd,KAAA,YACC,KAAA,IAAS,6BAA6B;AAAA,iBAqBzB,6BAAA,CACd,KAAA,YACC,KAAA,IAAS,2BAA2B;;;;;;AA3Pa;AAAG;;iBAqSvC,2BAAA,CACd,aAAA,EAAe,sBAAsB,cACrC,SAAA;;AAnSiB;AAGnB;;;;;;;;;;;;;;;;iBA8TgB,wBAAA,CACd,MAAA,EAAQ,MAAA,mBACR,MAAA,EAAQ,MAAM,mBACd,IAAA,qBACA,SAAA,GAAY,KAAA,uBACZ,KAAA;AAAA,iBAwLc,+BAAA,CACd,aAAA,EAAe,sBAAA,EACf,cAAA,EAAgB,uBAAA,EAChB,mBAAA,GAAqB,4BAAA,EACrB,iBAAA,GAAmB,oCAAA;AAAA,iBA6CL,6BAAA,CACd,QAAA,EAAU,sBAAsB,EAChC,IAAA;AAAA,iBAiHc,gCAAA,CACd,UAAA,UACA,WAAA,WAAsB,2BAA2B,gBACjD,IAAA;AAAA,iBAmHc,mCAAA,CACd,UAAA,EAAY,kCAAA,EACZ,IAAA;EAAA,SAES,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;AAAA,iBAKd,8BAAA,CACd,UAAA,UACA,UAAA,EAAY,6BAAA,EACZ,IAAA,sBACA,GAAA,EAAK,sBAAsB;AAAA,iBA0Bb,+BAAA,CACd,UAAA,EAAY,8BAAA,EACZ,IAAA;EAAA,SAES,UAAA;IAAA,SACE,OAAA;IAAA,SACA,UAAA;IAAA,SACA,UAAA,GAAa,MAAA;EAAA;EAAA,SAEf,QAAA;EAAA,SACA,OAAA,GAAU,aAAA;EAAA,SACV,iBAAA,GAAoB,8BAAA;EAAA,SACpB,EAAA;EAAA,SACA,MAAA;AAAA"}

package/dist/{framework-components-Ce_Cdw76.d.mts → framework-components-DdqvMc8S.d.mts}

@@ -1,4 +1,4 @@
-import { i as AuthoringContributions } from "./framework-authoring-Cv04iZjB.mjs";
+import { i as AuthoringContributions } from "./framework-authoring-Cyde8zSN.mjs";
 import { r as AnyCodecDescriptor } from "./codec-DCQAerzB.mjs";
 import { t as TypesImportSpec } from "./types-import-spec-DRKzrJ20.mjs";
 import { ColumnDefault, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue } from "@prisma-next/contract/types";
@@ -409,4 +409,4 @@ interface ExtensionInstance<TFamilyId extends string, TTargetId extends string>
 }
 //#endregion
 export { LoweredDefaultResult as A, ControlMutationDefaultEntry as C, DefaultFunctionLoweringHandler as D, DefaultFunctionLoweringContext as E, SourceSpan as F, MutationDefaultGeneratorDescriptor as M, ParsedDefaultFunctionCall as N, DefaultFunctionRegistry as O, SourceDiagnostic as P, checkContractComponentRequirements as S, ControlMutationDefaults as T, PackRefBase as _, ComponentMetadata as a, TargetInstance as b, DriverDescriptor as c, ExtensionDescriptor as d, ExtensionInstance as f, FamilyPackRef as g, FamilyInstance as h, ComponentDescriptor as i, LoweredDefaultValue as j, DefaultFunctionRegistryEntry as k, DriverInstance as l, FamilyDescriptor as m, AdapterInstance as n, ContractComponentRequirementsCheckInput as o, ExtensionPackRef as p, AdapterPackRef as r, ContractComponentRequirementsCheckResult as s, AdapterDescriptor as t, DriverPackRef as u, TargetBoundComponentDescriptor as v, ControlMutationDefaultRegistry as w, TargetPackRef as x, TargetDescriptor as y };
-//# sourceMappingURL=framework-components-Ce_Cdw76.d.mts.map
+//# sourceMappingURL=framework-components-DdqvMc8S.d.mts.map

package/dist/{framework-components-Ce_Cdw76.d.mts.map → framework-components-DdqvMc8S.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"framework-components-Ce_Cdw76.d.mts","names":[],"sources":["../src/shared/mutation-default-types.ts","../src/shared/framework-components.ts"],"mappings":"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"}
+{"version":3,"file":"framework-components-DdqvMc8S.d.mts","names":[],"sources":["../src/shared/mutation-default-types.ts","../src/shared/framework-components.ts"],"mappings":"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"}

package/dist/{psl-ast-CTuBYLYj.d.mts → psl-ast-DRzRF9rS.d.mts}

@@ -1,14 +1,7 @@
+import { G as PslSpan, L as PslDiagnosticCode, R as PslExtensionBlock, m as AuthoringPslBlockDescriptorNamespace } from "./framework-authoring-Cyde8zSN.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;
@@ -174,6 +167,23 @@ interface PslNamespace {
   readonly models: readonly PslModel[];
   readonly enums: readonly PslEnum[];
   readonly compositeTypes: readonly PslCompositeType[];
+  /**
+   * Extension-contributed top-level blocks parsed inside this namespace.
+   * These are the parsed AST nodes produced by the generic framework parser
+   * when it encounters a keyword claimed by a registered
+   * {@link AuthoringPslBlockDescriptorNamespace} entry.
+   *
+   * Absent when no extension blocks appear in this namespace. Order matches
+   * source order within the namespace; extension-contributed and built-in
+   * blocks live in their own slots, so a namespace mixing `model X { … }` and
+   * `policy_select Y { … }` keeps the model in `models` and the policy in
+   * `extensionBlocks`.
+   *
+   * Contrast with {@link ParsePslDocumentInput.pslBlockDescriptors}: that
+   * field holds the registry of declarative descriptors that teach the parser
+   * which keywords to accept; this field holds the resulting parsed nodes.
+   */
+  readonly extensionBlocks?: readonly PslExtensionBlock[];
   readonly span: PslSpan;
 }
 interface PslDocumentAst {
@@ -199,6 +209,30 @@ declare function flatPslCompositeTypes(ast: PslDocumentAst): readonly PslComposi
 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 {@link PslNamespace.extensionBlocks}: that field holds the
+   * parsed block nodes in a namespace; 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;
@@ -206,5 +240,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-CTuBYLYj.d.mts.map
+export { flatPslModels as A, PslReferentialAction as C, UNSPECIFIED_PSL_NAMESPACE_ID as D, PslUniqueConstraint as E, flatPslCompositeTypes as O, PslNamespace as S, PslTypesBlock as T, PslFieldAttribute as _, PslAttributeNamedArgument as a, PslModelAttribute as b, PslCompositeType as c, PslDefaultValue as d, PslDiagnostic as f, PslField as g, PslEnumValue as h, PslAttributeArgument as i, flatPslEnums as k, PslDefaultFunctionValue as l, PslEnum as m, ParsePslDocumentResult as n, PslAttributePositionalArgument as o, PslDocumentAst as p, PslAttribute as r, PslAttributeTarget as s, ParsePslDocumentInput as t, PslDefaultLiteralValue as u, PslIndexConstraint as v, PslTypeConstructorCall as w, PslNamedTypeDeclaration as x, PslModel as y };
+//# sourceMappingURL=psl-ast-DRzRF9rS.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"psl-ast-DRzRF9rS.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-CTuBYLYj.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-Cyde8zSN.mjs";
+import { c as CodecLookup } from "./codec-DCQAerzB.mjs";
+import { A as flatPslModels, C as PslReferentialAction, D as UNSPECIFIED_PSL_NAMESPACE_ID, E as PslUniqueConstraint, O as flatPslCompositeTypes, S as PslNamespace, T as PslTypesBlock, _ as PslFieldAttribute, a as PslAttributeNamedArgument, b as PslModelAttribute, c as PslCompositeType, d as PslDefaultValue, f as PslDiagnostic, g as PslField, h as PslEnumValue, i as PslAttributeArgument, k as flatPslEnums, l as PslDefaultFunctionValue, m as PslEnum, n as ParsePslDocumentResult, o as PslAttributePositionalArgument, p as PslDocumentAst, r as PslAttribute, s as PslAttributeTarget, t as ParsePslDocumentInput, u as PslDefaultLiteralValue, v as PslIndexConstraint, w as PslTypeConstructorCall, x as PslNamedTypeDeclaration, y as PslModel } from "./psl-ast-DRzRF9rS.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, 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, type PslPosition, PslReferentialAction, type PslSpan, PslTypeConstructorCall, PslTypesBlock, PslUniqueConstraint, UNSPECIFIED_PSL_NAMESPACE_ID, flatPslCompositeTypes, flatPslEnums, flatPslModels, 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"}