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

package/src/shared/framework-authoring.ts

@@ -7,8 +7,10 @@ import {
   isColumnDefaultLiteralInputValue,
   isExecutionMutationDefaultValue,
 } from '@prisma-next/contract/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Type } from 'arktype';
+import type { PslBlockParam } from './psl-extension-block';
 
 export type AuthoringArgRef = {
   readonly kind: 'arg';
@@ -157,10 +159,55 @@ export 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.
+ */
+export interface AuthoringPslBlockDescriptor {
+  readonly kind: 'pslBlock';
+  readonly keyword: string;
+  readonly discriminator: string;
+  readonly name: { readonly required: boolean };
+  readonly parameters: Record<string, PslBlockParam>;
+}
+
+export type AuthoringPslBlockDescriptorNamespace = {
+  readonly [name: string]: AuthoringPslBlockDescriptor | AuthoringPslBlockDescriptorNamespace;
+};
+
 export 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 the parsed block nodes themselves, which live in a
+   * namespace's `entries` under their discriminator key; this field holds the
+   * registry of descriptors that teach the parser how to read those blocks.
+   */
+  readonly pslBlockDescriptors?: AuthoringPslBlockDescriptorNamespace;
 }
 
 export function isAuthoringArgRef(value: unknown): value is AuthoringArgRef {
@@ -228,6 +275,42 @@ export function isAuthoringEntityTypeDescriptor(
   return typeof factory === 'function' || template !== undefined;
 }
 
+export function isAuthoringPslBlockDescriptor(
+  value: unknown,
+): value is AuthoringPslBlockDescriptor {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  const record = blindCast<
+    Record<string, unknown>,
+    'type-guard probing an unknown candidate-descriptor object for known property names'
+  >(value);
+  if (record['kind'] !== 'pslBlock') {
+    return false;
+  }
+  const keyword = record['keyword'];
+  if (typeof keyword !== 'string' || keyword.length === 0) {
+    return false;
+  }
+  const discriminator = record['discriminator'];
+  if (typeof discriminator !== 'string' || discriminator.length === 0) {
+    return false;
+  }
+  const name = record['name'];
+  if (typeof name !== 'object' || name === null) {
+    return false;
+  }
+  const nameRecord = blindCast<
+    Record<string, unknown>,
+    'type-guard probing the name property of a candidate pslBlock descriptor'
+  >(name);
+  if (typeof nameRecord['required'] !== 'boolean') {
+    return false;
+  }
+  const parameters = record['parameters'];
+  return typeof parameters === 'object' && parameters !== null && !Array.isArray(parameters);
+}
+
 /**
  * Returns true when `namespace` is a non-leaf key in `contributions.field`.
  *
@@ -341,10 +424,127 @@ function collectAuthoringLeafPaths(
   return paths;
 }
 
+interface AuthoringLeafEntry {
+  readonly path: string;
+  readonly discriminator: string;
+}
+
+function collectAuthoringLeafDiscriminators(
+  namespace: Readonly<Record<string, unknown>>,
+  isLeaf: (value: unknown) => boolean,
+  label: string,
+  path: readonly string[] = [],
+): AuthoringLeafEntry[] {
+  const entries: AuthoringLeafEntry[] = [];
+  for (const [key, value] of Object.entries(namespace)) {
+    const currentPath = [...path, key];
+    if (isLeaf(value)) {
+      const record = blindCast<
+        Record<string, unknown>,
+        'discriminator extraction from a leaf already validated by isLeaf'
+      >(value);
+      const discriminator = record['discriminator'];
+      if (typeof discriminator === 'string' && discriminator.length > 0) {
+        entries.push({ path: currentPath.join('.'), discriminator });
+      }
+      continue;
+    }
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const record = blindCast<
+        Readonly<Record<string, unknown>>,
+        'walker inspects a non-leaf value for descriptor-shaped keys before recursing'
+      >(value);
+      // A value carrying descriptor-shaped keys (`kind`/`keyword`/`discriminator`)
+      // but failing `isAuthoringPslBlockDescriptor` (e.g. missing `parameters`) is
+      // a malformed declarative descriptor. Descending into it as a sub-namespace
+      // would silently skip it, so a half-built contribution would pass validation.
+      // Reject it at load time instead, naming the path and what's wrong.
+      //
+      // A valid sub-namespace whose key happens to be named `kind`, `keyword`, or
+      // `discriminator` (but which does not look like a descriptor overall) must
+      // still descend normally — the check requires descriptor-shaped keys present
+      // AND the leaf guard rejecting it.
+      if (
+        (record['kind'] !== undefined ||
+          record['keyword'] !== undefined ||
+          record['discriminator'] !== undefined) &&
+        !isLeaf(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 ${label} contribution at "${currentPath.join('.')}". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the ${label} 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(...collectAuthoringLeafDiscriminators(record, isLeaf, label, currentPath));
+    }
+  }
+  return entries;
+}
+
+/**
+ * Throws when two or more entries in the same namespace share a discriminator.
+ * Duplicate discriminators within a namespace make dispatch ambiguous — the
+ * 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 {
+  const seen = new Map<string, string>();
+  for (const { path, discriminator } of entries) {
+    const existing = seen.get(discriminator);
+    if (existing !== undefined) {
+      throw new Error(
+        `Duplicate ${label} discriminator "${discriminator}" registered at both "${existing}" and "${path}". Each ${label} contribution must use a unique discriminator.`,
+      );
+    }
+    seen.set(discriminator, path);
+  }
+}
+
+/**
+ * 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).
+ */
+function assertPslBlocksHaveFactories(
+  entityTypeNamespace: AuthoringEntityTypeNamespace,
+  pslBlockNamespace: AuthoringPslBlockDescriptorNamespace,
+): void {
+  const blockEntries = collectAuthoringLeafDiscriminators(
+    pslBlockNamespace,
+    isAuthoringPslBlockDescriptor,
+    'pslBlock',
+  );
+  const entityEntries = collectAuthoringLeafDiscriminators(
+    entityTypeNamespace,
+    isAuthoringEntityTypeDescriptor,
+    'entityType',
+  );
+
+  assertUniqueDiscriminators(blockEntries, 'pslBlock');
+  assertUniqueDiscriminators(entityEntries, 'entityType');
+
+  const entityDiscriminators = new Set(entityEntries.map((entry) => entry.discriminator));
+
+  for (const block of blockEntries) {
+    if (!entityDiscriminators.has(block.discriminator)) {
+      throw new Error(
+        `Incomplete extension contribution: pslBlock helper "${block.path}" registers discriminator "${block.discriminator}" but no entityType contribution shares that discriminator. An extension-contributed PSL block requires a matching entityType factory so the parsed AST node can lower to an IR class instance; add an entityType helper with discriminator "${block.discriminator}".`,
+      );
+    }
+  }
+}
+
 export function assertNoCrossRegistryCollisions(
   typeNamespace: AuthoringTypeNamespace,
   fieldNamespace: AuthoringFieldNamespace,
   entityTypeNamespace: AuthoringEntityTypeNamespace = {},
+  pslBlockNamespace: AuthoringPslBlockDescriptorNamespace = {},
 ): void {
   const typePaths = new Set(
     collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),
@@ -360,20 +560,33 @@ export function assertNoCrossRegistryCollisions(
   // `mergeHelperNamespaces` in composed-authoring-helpers.ts), which throws
   // on same-path registrations within any single registry before this check
   // runs. This function only handles the cross-registry case.
+  //
+  // Cross-registry collisions are checked among `type` / `field` /
+  // `entityTypes` only — these three are user-facing helper paths that PSL
+  // must resolve unambiguously. `pslBlockDescriptors` is an internal
+  // framework index consumed by parser and printer dispatch, not a
+  // user-facing helper path; the natural authoring pattern is the same
+  // path key in `entityTypes` and `pslBlockDescriptors` for a single
+  // contribution. The block→factory link is enforced by
+  // `assertPslBlocksHaveFactories` via the discriminator string, not by path.
+  const ambiguityHint =
+    'Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.';
   for (const fieldPath of fieldPaths) {
     if (typePaths.has(fieldPath)) {
       throw new Error(
-        `Ambiguous authoring registry path "${fieldPath}". The same path is registered as both a type constructor and a field preset; PSL resolution would be ambiguous. Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.`,
+        `Ambiguous authoring registry path "${fieldPath}". The same path is registered as both a type constructor and a field preset; PSL resolution would be ambiguous. ${ambiguityHint}`,
       );
     }
   }
   for (const entityPath of entityPaths) {
     if (typePaths.has(entityPath) || fieldPaths.has(entityPath)) {
       throw new Error(
-        `Ambiguous authoring registry path "${entityPath}". The same path is registered as an entity contribution AND as a type constructor or field preset; PSL resolution would be ambiguous. Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.`,
+        `Ambiguous authoring registry path "${entityPath}". The same path is registered as an entity contribution AND as a type constructor or field preset; PSL resolution would be ambiguous. ${ambiguityHint}`,
       );
     }
   }
+
+  assertPslBlocksHaveFactories(entityTypeNamespace, pslBlockNamespace);
 }
 
 export function resolveAuthoringTemplateValue(

package/src/shared/framework-components.ts

@@ -227,6 +227,8 @@ export type TargetPackRef<
   TTargetId extends string = string,
 > = PackRefBase<'target', TFamilyId> & {
   readonly targetId: TTargetId;
+  /** The namespace a bare (un-namespaced) entity name resolves to for this target (e.g. Postgres `'public'`). */
+  readonly defaultNamespaceId: string;
 };
 
 export type AdapterPackRef<

package/src/shared/psl-extension-block.ts

@@ -0,0 +1,184 @@
+/**
+ * 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.
+ */
+
+export interface PslPosition {
+  readonly offset: number;
+  readonly line: number;
+  readonly column: number;
+}
+
+export interface PslSpan {
+  readonly start: PslPosition;
+  readonly end: PslPosition;
+}
+
+export 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.
+ */
+export type PslBlockParam =
+  | PslBlockParamRef
+  | PslBlockParamValue
+  | PslBlockParamOption
+  | PslBlockParamList;
+
+export interface PslBlockParamRef {
+  readonly kind: 'ref';
+  readonly refKind: string;
+  readonly scope: 'same-namespace' | 'same-space' | 'cross-space';
+  readonly required?: boolean;
+}
+
+export interface PslBlockParamValue {
+  readonly kind: 'value';
+  readonly codecId: string;
+  readonly required?: boolean;
+}
+
+export interface PslBlockParamOption {
+  readonly kind: 'option';
+  readonly values: readonly string[];
+  readonly required?: boolean;
+}
+
+export 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.
+ */
+export type PslExtensionBlockParamValue =
+  | PslExtensionBlockParamRef
+  | PslExtensionBlockParamScalarValue
+  | PslExtensionBlockParamOption
+  | PslExtensionBlockParamList;
+
+export interface PslExtensionBlockParamRef {
+  readonly kind: 'ref';
+  readonly identifier: string;
+  readonly span: PslSpan;
+}
+
+export interface PslExtensionBlockParamScalarValue {
+  readonly kind: 'value';
+  readonly raw: string;
+  readonly span: PslSpan;
+}
+
+export interface PslExtensionBlockParamOption {
+  readonly kind: 'option';
+  readonly token: string;
+  readonly span: PslSpan;
+}
+
+export 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.
+ */
+export interface PslExtensionBlock {
+  readonly kind: string;
+  readonly name: string;
+  readonly parameters: Record<string, PslExtensionBlockParamValue>;
+  readonly span: PslSpan;
+}

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

@@ -1,183 +0,0 @@
-import { ColumnDefault, ExecutionMutationDefaultPhases } from "@prisma-next/contract/types";
-import { Type } from "arktype";
-
-//#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;
-};
-interface AuthoringContributions {
-  readonly type?: AuthoringTypeNamespace;
-  readonly field?: AuthoringFieldNamespace;
-  readonly entityTypes?: AuthoringEntityTypeNamespace;
-}
-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;
-/**
- * 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): 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 { isAuthoringEntityTypeDescriptor as C, resolveAuthoringTemplateValue as D, mergeAuthoringNamespaces as E, validateAuthoringHelperArguments as O, isAuthoringArgRef as S, isAuthoringTypeConstructorDescriptor as T, assertNoCrossRegistryCollisions as _, AuthoringEntityContext as a, instantiateAuthoringFieldPreset as b, AuthoringEntityTypeNamespace as c, AuthoringFieldPresetDescriptor as d, AuthoringFieldPresetOutput as f, AuthoringTypeNamespace as g, AuthoringTypeConstructorDescriptor as h, AuthoringContributions as i, AuthoringEntityTypeTemplateOutput as l, AuthoringTemplateValue as m, AuthoringArgumentDescriptor as n, AuthoringEntityTypeDescriptor as o, AuthoringStorageTypeTemplate as p, AuthoringColumnDefaultTemplate as r, AuthoringEntityTypeFactoryOutput as s, AuthoringArgRef as t, AuthoringFieldNamespace as u, hasRegisteredFieldNamespace as v, isAuthoringFieldPresetDescriptor as w, instantiateAuthoringTypeConstructor as x, instantiateAuthoringEntityType as y };
-//# sourceMappingURL=framework-authoring-BPPe9C9D.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"framework-authoring-BPPe9C9D.d.mts","names":[],"sources":["../src/shared/framework-authoring.ts"],"mappings":"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"}