@prisma/orm-framework 0.16.0

package/dist/index-GY2oGH9L.d.mts

@@ -0,0 +1,120 @@
+//#region ../../../1-framework/1-core/ts-render/dist/index.d.mts
+//#region src/json-to-ts-source.d.ts
+/**
+ * Pure JSON-to-TypeScript-source printer.
+ *
+ * This module is the second stage of the codec → TS pipeline:
+ *
+ *     jsValue  →  codec.encodeJson  →  JsonValue  →  jsonToTsSource  →  TS source text
+ *
+ * Stage 1 (`codec.encodeJson`) is a codec responsibility — date serialization,
+ * opaque domain types (vector, bigint, uuid), JSON canonicalization. Stage 2
+ * (this module) is a pure JSON-to-TS printer that must never grow type-specific
+ * branches.
+ *
+ * To render a non-JSON JS value (Date, Vector, BigInt, Buffer, …), encode it
+ * through the relevant codec's `encodeJson` first. Adding special cases to
+ * this file is not the answer — that's what codecs are for.
+ */
+type JsonValue = string | number | boolean | null | readonly JsonValue[] | JsonObject;
+type JsonObject = {
+  readonly [key: string]: JsonValue | undefined;
+};
+/**
+ * Render a JSON-compatible value as a TypeScript source-text literal.
+ *
+ * Accepts `unknown` for ergonomics with structural types (e.g. `ColumnSpec`,
+ * `ForeignKeySpec`) whose fields are all JSON-compatible but whose interfaces
+ * lack the index signature TypeScript requires for `JsonObject` assignability.
+ * Non-JSON values (Date, Symbol, Function, etc.) throw at runtime.
+ */
+declare function jsonToTsSource(value: unknown): string;
+//#endregion
+//#region src/ts-expression.d.ts
+/**
+ * Declarative contribution to the `import` block of a rendered TypeScript
+ * source file. Each node in an IR declares which symbols it needs from which
+ * modules; the top-level renderer deduplicates across nodes and emits one
+ * `import { a, b, c } from "…"` line per module.
+ *
+ * `kind` defaults to `"named"` (e.g. `import { a } from "m"`). Setting it to
+ * `"default"` emits `import a from "m"`. `attributes`, if provided, emits an
+ * import attributes clause (`with { type: "json" }`) verbatim — required for
+ * JSON module imports in the rendered scaffolds.
+ *
+ * `alias`, when present and different from `symbol`, renders `symbol as alias`.
+ * `typeOnly` marks the symbol as a type import: when every symbol contributed
+ * for a module is `typeOnly`, the whole statement collapses to
+ * `import type { … } from "m"`; when a module mixes value and type symbols, the
+ * type-only ones carry a per-specifier `type` prefix (`import { type T, val }`).
+ */
+interface ImportRequirement {
+  readonly moduleSpecifier: string;
+  readonly symbol: string;
+  readonly kind?: 'named' | 'default';
+  readonly attributes?: Readonly<Record<string, string>>;
+  readonly alias?: string;
+  readonly typeOnly?: boolean;
+}
+/**
+ * Abstract base class for any IR node that can be emitted as a TypeScript
+ * expression and declare its own import requirements.
+ *
+ * A top-level renderer walks an array of these polymorphically, concatenates
+ * `renderTypeScript()` results, and aggregates `importRequirements()` into a
+ * deduplicated import block.
+ */
+declare abstract class TsExpression {
+  abstract renderTypeScript(): string;
+  abstract importRequirements(): readonly ImportRequirement[];
+}
+//#endregion
+//#region src/render-imports.d.ts
+/**
+ * Render an aggregated `import` block from a flat list of
+ * `ImportRequirement`s. Each target's migration renderer collects
+ * requirements polymorphically from its call nodes and pipes them here.
+ *
+ * The emitter invariants:
+ *
+ * - **Usually one line per module specifier.** Named imports are aggregated
+ *   and emitted sorted; a single default symbol is combined onto the same
+ *   line when attributes agree (`import def, { a, b } from "m";`). Aliased
+ *   symbols render `symbol as alias`. When every symbol for a module is
+ *   `typeOnly`, the statement collapses to `import type { … }`; a module
+ *   mixing value and type symbols prefixes the type-only ones
+ *   (`import { type T, v }`). Exceptions that split into multiple lines: a
+ *   fully type-only statement with both a default and one or more named
+ *   bindings (`import type D from "m";` then `import type { N } from "m";`,
+ *   because TypeScript rejects `import type D, { N } from "m"` — TS1363),
+ *   and multiple distinct default symbols (see below).
+ * - **Multiple distinct default symbols per module are allowed.** JS permits
+ *   re-importing the same specifier under different default-binding names
+ *   (`import a from 'm'; import b from 'm';`), so each distinct default
+ *   symbol renders its own `import` line, sorted alphabetically; a repeated
+ *   requirement for the same symbol still collapses into one binding,
+ *   merging `typeOnly` by AND.
+ * - **Attribute unanimity per module.** All requirements for the same
+ *   module specifier must carry the same (or no) `attributes` map.
+ *   Divergent attribute maps throw — they can't collapse to one line
+ *   and there's no user-resolvable recovery at this layer.
+ * - **Distinct (symbol, alias) pairs are distinct bindings.** TypeScript
+ *   permits importing the same export under multiple local names, so
+ *   `{ A }` + `{ A as B }` renders as `import { A, A as B } from "m"` and
+ *   `{ A as B }` + `{ A as C }` renders as `import { A as B, A as C } from "m"`.
+ *   Truly identical `(symbol, alias)` pairs still collapse to one binding,
+ *   merging `typeOnly` by AND.
+ * - **Deterministic ordering.** Modules are emitted sorted by specifier;
+ *   within a module, named bindings are emitted sorted by `(symbol, alias)`
+ *   using JavaScript code-unit comparison, with the un-aliased form (no
+ *   alias) treated as alias `""` so it sorts before any aliased form of the
+ *   same symbol.
+ *
+ * Returns a string containing one or more import lines per module (see the
+ * splitting exceptions above), joined by `\n` (no trailing newline). An
+ * empty requirement list returns `""`.
+ */
+declare function renderImports(requirements: readonly ImportRequirement[]): string;
+//#endregion
+export { jsonToTsSource as a, TsExpression as i, JsonObject as n, renderImports as o, JsonValue as r, ImportRequirement as t };
+//# sourceMappingURL=index-GY2oGH9L.d.mts.map

package/dist/index-GY2oGH9L.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-GY2oGH9L.d.mts","names":[],"sources":["../../../../1-framework/1-core/ts-render/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;KAiBK,wDAAwD,cAAc;KACtE;YACO,cAAc;;;;;;;;;;iBAUT,eAAe;;;;;;;;;;;;;;;;;;;;UAoBtB;WACC;WACA;WACA;WACA,aAAa,SAAS;WACtB;WACA;;;;;;;;;;uBAUY;WACZ;WACA,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDzB,cAAc,uBAAuB"}

package/dist/internal-error-BIc-ehme-ouBQPoEL.mjs

@@ -0,0 +1,24 @@
+//#region ../../../1-framework/0-foundation/utils/dist/internal-error-BIc-ehme.mjs
+/**
+* A bug in Prisma Next, not a user error. Never catch this except at the
+* outermost boundary for crash reporting — an InternalError means an invariant
+* broke and the process cannot reliably continue. User-facing failures use
+* `structuredError` with a dotted code instead.
+*/
+var InternalError = class extends Error {
+	isPrismaInternalError = true;
+	constructor(message, options) {
+		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.name = "InternalError";
+	}
+};
+function isInternalError(e) {
+	return typeof e === "object" && e !== null && "isPrismaInternalError" in e && e.isPrismaInternalError === true;
+}
+function assertNever(value, message) {
+	throw new InternalError(message ?? `Unreachable: unexpected value ${String(value)}`);
+}
+//#endregion
+export { assertNever as n, isInternalError as r, InternalError as t };
+
+//# sourceMappingURL=internal-error-BIc-ehme-ouBQPoEL.mjs.map

package/dist/internal-error-BIc-ehme-ouBQPoEL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-error-BIc-ehme-ouBQPoEL.mjs","names":[],"sources":["../../../../1-framework/0-foundation/utils/dist/internal-error-BIc-ehme.mjs"],"sourcesContent":["//#region src/internal-error.ts\n/**\n* A bug in Prisma Next, not a user error. Never catch this except at the\n* outermost boundary for crash reporting — an InternalError means an invariant\n* broke and the process cannot reliably continue. User-facing failures use\n* `structuredError` with a dotted code instead.\n*/\nvar InternalError = class extends Error {\n\tisPrismaInternalError = true;\n\tconstructor(message, options) {\n\t\tsuper(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);\n\t\tthis.name = \"InternalError\";\n\t}\n};\nfunction isInternalError(e) {\n\treturn typeof e === \"object\" && e !== null && \"isPrismaInternalError\" in e && e.isPrismaInternalError === true;\n}\nfunction assertNever(value, message) {\n\tthrow new InternalError(message ?? `Unreachable: unexpected value ${String(value)}`);\n}\n//#endregion\nexport { assertNever as n, isInternalError as r, InternalError as t };\n\n//# sourceMappingURL=internal-error-BIc-ehme.mjs.map"],"mappings":";;;;;;;AAOA,IAAI,gBAAgB,cAAc,MAAM;CACvC,wBAAwB;CACxB,YAAY,SAAS,SAAS;EAC7B,MAAM,SAAS,SAAS,UAAU,KAAK,IAAI,EAAE,OAAO,QAAQ,MAAM,IAAI,KAAK,CAAC;EAC5E,KAAK,OAAO;CACb;AACD;AACA,SAAS,gBAAgB,GAAG;CAC3B,OAAO,OAAO,MAAM,YAAY,MAAM,QAAQ,2BAA2B,KAAK,EAAE,0BAA0B;AAC3G;AACA,SAAS,YAAY,OAAO,SAAS;CACpC,MAAM,IAAI,cAAc,WAAW,iCAAiC,OAAO,KAAK,GAAG;AACpF"}

package/dist/internal-error-kK8QvlDE.d.mts

@@ -0,0 +1,19 @@
+//#region ../../../1-framework/0-foundation/utils/dist/internal-error.d.mts
+//#region src/internal-error.d.ts
+/**
+ * A bug in Prisma Next, not a user error. Never catch this except at the
+ * outermost boundary for crash reporting — an InternalError means an invariant
+ * broke and the process cannot reliably continue. User-facing failures use
+ * `structuredError` with a dotted code instead.
+ */
+declare class InternalError extends Error {
+  readonly isPrismaInternalError = true;
+  constructor(message: string, options?: {
+    readonly cause?: unknown;
+  });
+}
+declare function isInternalError(e: unknown): e is InternalError;
+declare function assertNever(value: never, message?: string): never;
+//#endregion
+export { assertNever as n, isInternalError as r, InternalError as t };
+//# sourceMappingURL=internal-error-kK8QvlDE.d.mts.map

package/dist/internal-error-kK8QvlDE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-error-kK8QvlDE.d.mts","names":[],"sources":["../../../../1-framework/0-foundation/utils/dist/internal-error.d.mts"],"mappings":";;;;;;;;cAOc,sBAAsB;WACzB;EACT,YAAY,iBAAiB;aAClB;;;iBAGI,gBAAgB,aAAa,KAAK;iBAClC,YAAY,cAAc"}

package/dist/ir-BvE7L9FK.d.mts

@@ -0,0 +1,359 @@
+import { J as StorageBase, Z as StorageNamespace, n as ApplicationDomain } from "./domain-envelope-D6Wn9AmZ-BqZKTT9U.mjs";
+import { Type } from "arktype";
+//#region ../../../1-framework/1-core/framework-components/dist/ir.d.mts
+//#region src/ir/ir-node.d.ts
+/**
+ * Framework-level IR alphabet.
+ *
+ * The framework's contribution to Contract IR / Schema IR is a common
+ * root for the IR class hierarchy and a freeze affordance. Family
+ * abstract bases (e.g. `SqlNode`, `MongoSchemaIRNode`) refine the alphabet
+ * for their family shape; targets ship the concrete classes.
+ *
+ * `kind` is an optional discriminator on the base. Families and leaves
+ * that benefit from discriminated-union dispatch declare their own
+ * literal `kind` at the level that earns it — Mongo leaves carry
+ * per-class literals (`readonly kind = 'mongo-collection' as const`)
+ * because Mongo IR has polymorphic walkers; SQL declares a single
+ * family-level `kind = 'sql'` on `SqlNode` because SQL IR has no
+ * polymorphic dispatch today. No framework consumer dispatches on
+ * `IRNode.kind` at the BASE type — every dispatch site narrows
+ * through a union of leaves where each leaf carries a literal kind, so
+ * requiring `kind` at the base would be unearned. Future leaves that
+ * earn polymorphic dispatch override with a required literal at that
+ * leaf (e.g. `override readonly kind = 'pack-contributed-kind' as const`).
+ *
+ * `IRNodeBase` carries no methods: the freeze-and-assign affordance
+ * lives in the free `freezeNode` helper below. Keeping `freezeNode` out
+ * of the class type means an emitted contract literal type
+ * (`{ readonly kind: 'mongo-collection', ... }` or an unkeyed literal
+ * like `{ nativeType, codecId, nullable }`) is structurally assignable
+ * to its class type — a `protected freeze()` instance method would
+ * otherwise leak into the public type surface and require the literal
+ * to carry it too.
+ *
+ * Subclasses construct fields then call `freezeNode(this)` to seal the
+ * instance. Frozen instances + plain readonly fields keep IR nodes
+ * JSON-clean by construction, so `JSON.stringify(node)` produces canonical
+ * JSON without a `toJSON()` method. The `ContractSerializer` SPI handles
+ * round-trip from canonical JSON back to typed class instances.
+ *
+ * The name (`IRNode` / `IRNodeBase`) reflects the dual-hierarchy reality:
+ * this base is the common root for both Contract IR and Schema IR class
+ * hierarchies, not a Schema-IR-specific alphabet.
+ */
+interface IRNode {
+  readonly kind?: string;
+}
+declare abstract class IRNodeBase implements IRNode {
+  abstract readonly kind?: string;
+}
+/**
+ * Seal an IR class instance after its constructor has assigned all
+ * fields. The free-helper form (rather than a `protected freeze()`
+ * instance method) keeps the class type structurally narrow so emitted
+ * contract literal types remain assignable to their class types.
+ *
+ * The helper name stays `freezeNode` — it operates on IR nodes
+ * regardless of root naming.
+ */
+declare function freezeNode<T extends IRNode>(node: T): T;
+//#endregion
+//#region src/ir/namespace.d.ts
+/**
+ * Reserved sentinel namespace id for the late-bound storage slot —
+ * the slot whose binding the target resolves at connection time
+ * rather than at authoring time. Postgres uses it for `search_path`
+ * late binding; SQLite uses it for the trivial singleton; Mongo uses
+ * it for the connection's `db` binding.
+ *
+ * Materialised target-side as a singleton subclass of the target's
+ * `NamespaceBase` concretion that overrides the namespace's
+ * qualifier-emission methods to elide the prefix entirely. Call sites
+ * stay polymorphic and never branch on `id === UNBOUND_NAMESPACE_ID`
+ * — the singleton's overrides drop the qualifier so emitted SQL / Mongo
+ * commands look unqualified.
+ *
+ * The double-underscore decoration marks the id as a framework-reserved
+ * coordinate when it appears in a JSON envelope (cold-read-as-reserved
+ * — no realistic collision with user-declared namespace names).
+ *
+ * Encoded as an exported const (rather than scattered string literals)
+ * so the sentinel-id invariant is single-sourced: any production-source
+ * site that constructs an unbound-namespace singleton imports this
+ * constant.
+ */
+declare const UNBOUND_NAMESPACE_ID: "__unbound__";
+/**
+ * Framework-level building block for a "namespace" — the database-level
+ * grouping under which storage objects (tables, collections, enums, …)
+ * reside. Each target's namespace concretion maps the framework concept to
+ * a target-native binding:
+ *
+ * - Postgres: a schema (`CREATE SCHEMA …`); rendered as `"<schema>"`.
+ * - SQLite: the singleton `UNBOUND_NAMESPACE_ID`; emitted SQL has no qualifier.
+ * - Mongo: the connection's `db` field; addressed as a database name.
+ *
+ * See `UNBOUND_NAMESPACE_ID` above for the sentinel id and the
+ * singleton-subclass pattern that materialises it.
+ *
+ * The framework promises only the coordinate (`id`) — the named storage
+ * entities a namespace contains are family-typed (SQL contributes
+ * `table` / `type`, Mongo contributes `collection`, future families pick
+ * their own native idiom under `entries`). Generic consumers walking "all
+ * named entries" go through a family-typed namespace, not the framework
+ * `Namespace`.
+ *
+ * Every namespace concretion (e.g. family-built SQL namespaces,
+ * `MongoUnboundNamespace`, target-promoted namespaces like
+ * `PostgresSchema`) carries exactly: `id` (enumerable string),
+ * `entries` (frozen object holding entity-kind slot maps), and `kind`
+ * (non-enumerable string discriminator set via `Object.defineProperty`).
+ * Each slot map under `entries` uses a singular essence key (`table`,
+ * `type`, `collection`, …) mapping entity names to IR classes. No other
+ * own-enumerable data lives on a namespace; non-entity computed data lives
+ * on the surrounding storage or contract IR. The framework's
+ * `elementCoordinates(storage)` walk relies on this invariant to enumerate
+ * entities structurally without family-specific knowledge.
+ */
+interface Namespace extends IRNode, StorageNamespace {
+  readonly kind: string;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+  /**
+   * Whether this namespace is the late-bound unbound slot (see
+   * {@link UNBOUND_NAMESPACE_ID}). Optional so JSON-shaped structural
+   * satisfiers remain valid; every hydrated `NamespaceBase` concretion
+   * answers it.
+   */
+  readonly isUnbound?: boolean;
+}
+declare abstract class NamespaceBase extends IRNodeBase implements Namespace {
+  abstract readonly id: string;
+  abstract readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+  abstract readonly kind: string;
+  /**
+   * Answers "am I the unbound namespace" as node behavior, so consumers
+   * never compare ids against the sentinel. This getter is the single
+   * encapsulated place the {@link UNBOUND_NAMESPACE_ID} comparison lives.
+   */
+  get isUnbound(): boolean;
+}
+//#endregion
+//#region src/ir/storage.d.ts
+/**
+ * Canonical address for a named entity in Contract IR / Schema IR.
+ *
+ * `plane` is `'domain' | 'storage'`: which top-level contract plane the
+ * entity lives on. Domain-side walks yield `plane: 'domain'` via
+ * {@link domainElementCoordinates}; {@link elementCoordinates} over storage
+ * yields `plane: 'storage'`.
+ *
+ * Cross-plane references obey a directional invariant: domain → storage is
+ * allowed; storage → domain is forbidden. That rule is enforced by a
+ * separate validator, not by constraining this coordinate shape — the
+ * coordinate carries the axis the validator checks.
+ *
+ * Iteration order over namespace properties follows `Object.entries` order;
+ * consumers that depend on ordering must sort.
+ */
+interface EntityCoordinate {
+  readonly plane: 'domain' | 'storage';
+  readonly namespaceId: string;
+  readonly entityKind: string;
+  readonly entityName: string;
+}
+/**
+ * Lazy walk over every named storage entity in a `Storage`-shaped
+ * value, yielded as {@link EntityCoordinate} tuples with
+ * `plane: 'storage'` (the parameter type binds the plane).
+ *
+ * Iterates each namespace's `entries` kind 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 kind vocabulary is required.
+ */
+declare function elementCoordinates(storage: Pick<StorageBase, 'namespaces'>): Generator<EntityCoordinate>;
+/**
+ * Canonical, collision-safe key for an {@link EntityCoordinate}. Encodes each
+ * axis individually with `JSON.stringify` before joining with `-`, so no
+ * namespace id, entity kind, or entity name can forge a collision by
+ * embedding the delimiter itself (e.g. a delimiter of `:` would let
+ * `('a', 'b:c', 'd')` collide with `('a:b', 'c', 'd')`) — each component is
+ * quoted, and any `-` or `"` inside it is escaped or safely inside those
+ * quotes.
+ *
+ * The single shared key every coordinate-driven ownership/omission/collision
+ * check should use — `contract infer`'s pack-described-element omission and
+ * the migration tools' cross-space disjointness check both key on this.
+ */
+declare function coordinateKey(coordinate: Pick<EntityCoordinate, 'namespaceId' | 'entityKind' | 'entityName'>): string;
+/**
+ * Looks up a single entity in a `Storage`-shaped value by its full coordinate.
+ * Returns `undefined` if the namespace, entity kind, or entity name is absent.
+ * The type parameter is a caller assertion — the walk itself is structural
+ * and cannot verify the entity's shape.
+ */
+declare function entityAt<T = unknown>(storage: Pick<StorageBase, 'namespaces'>, coord: Pick<EntityCoordinate, 'namespaceId' | 'entityKind' | 'entityName'>): T | undefined;
+/**
+ * Framework-level promise that every Contract IR / Schema IR carries a
+ * collection of namespaces keyed by namespace id. Family storage
+ * concretions (`SqlStorage`, `MongoStorage`) refine the shape with
+ * family-specific fields (tables, collections, enums, …); target
+ * concretions add target fields where the family vocabulary doesn't
+ * reach.
+ *
+ * Keeping `namespaces` at the framework layer enforces that every storage
+ * object — across any target — is namespace-scoped. The framework can
+ * therefore walk the namespace map without knowing the family alphabet, and
+ * the `(namespace.id, name)` keying that the verifier and planner depend on
+ * is honest at every layer.
+ *
+ * Extends `IRNode` so the framework's IR-walking surfaces (verifiers,
+ * serializers) can dispatch on `Storage`-typed fields through the same
+ * IR-node alphabet as every other node — the structural dual already
+ * holds in code (every concrete storage class extends an IR-node base);
+ * the interface promotion makes the typing honest.
+ *
+ * **Persisted envelope shape is target-owned, not framework-promised.**
+ * Whether the `namespaces` map appears in the on-disk JSON envelope is
+ * a per-target decision made by `ContractSerializer.serializeContract`.
+ * Some targets emit a JSON-clean namespace shape that round-trips
+ * through `JSON.stringify` cleanly (SQL today via the family-layer
+ * identity serializer); others ship runtime-only fields on their
+ * namespace concretions and override `serializeContract` to strip
+ * them (Mongo). Future open (F16): extend the per-target
+ * `ContractSerializer` integration-test surface with an explicit
+ * envelope-shape assertion for each target, so the strip-vs-pass-through
+ * choice is locked at test time rather than implied by the override
+ * presence/absence. Earned by PR2's per-target namespace lift, when
+ * `PostgresSchema` / `SqliteUnboundDatabase` start carrying
+ * target-specific fields.
+ */
+interface Storage extends IRNode {
+  readonly namespaces: Readonly<Record<string, Namespace>>;
+}
+//#endregion
+//#region src/ir/contract-view.d.ts
+/**
+ * Extracts the entries map of a contract's single default namespace
+ * (`UNBOUND_NAMESPACE_ID`). Both single-namespace families (Mongo, SQLite)
+ * store all entities under this one namespace.
+ */
+type DefaultNamespaceEntries<TStorage extends {
+  readonly namespaces: object;
+}> = TStorage['namespaces'] extends Record<typeof UNBOUND_NAMESPACE_ID, {
+  readonly entries: infer E;
+}> ? E : never;
+/**
+ * Generic single-namespace projection shape — one namespace's entity-kind slots.
+ * A family supplies:
+ *  - `TEntries` — the family's `*NamespaceEntries` type for the namespace.
+ *  - `TBuiltinKinds` — the union of the family's statically-named built-in kind
+ *    keys (Mongo `'collection'`; SQL `'table' | 'valueSet'`).
+ *
+ * Each built-in kind becomes a top-level accessor; the remaining pack-contributed
+ * kinds stay under `.entries` (keyed by their registered singular kind string).
+ *
+ * A built-in kind that the emitted contract does not carry resolves to an empty
+ * map (`Record<string, never>`), matching the runtime which always materializes
+ * each built-in slot. The `& string` index-signature member of `TEntries` is
+ * excluded from `.entries` so only the literal pack-kind keys remain.
+ */
+type SingleNamespaceView<TEntries, TBuiltinKinds extends string> = { readonly [K in TBuiltinKinds]-?: K extends keyof TEntries ? NonNullable<TEntries[K]> : Record<string, never>; } & {
+  readonly entries: { readonly [K in Exclude<keyof TEntries, TBuiltinKinds | number | symbol> as string extends K ? never : K]: TEntries[K]; };
+};
+/** The `entries` shape of one namespace in a storage map. */
+type EntriesOf<TNamespace> = TNamespace extends {
+  readonly entries: infer E;
+} ? E : never;
+/**
+ * The namespace-keyed entity-view map — every storage namespace keyed by its raw
+ * id, each projected to its {@link SingleNamespaceView}. Mirrors
+ * `NamespacedEnums` from `@internal/contract/enum-accessor`: the migration
+ * author's storage-side `view.namespace.<nsId>` is the twin of the runtime's
+ * `db.enums.<nsId>`. Nesting the schema map under one fixed `namespace` member
+ * makes it collision-proof — a schema named `storage` is `view.namespace.storage`,
+ * never a contract-root key.
+ */
+type NamespacedEntities<TStorage extends {
+  readonly namespaces: object;
+}, TBuiltinKinds extends string> = { readonly [Ns in keyof TStorage['namespaces']]: SingleNamespaceView<EntriesOf<TStorage['namespaces'][Ns]>, TBuiltinKinds>; };
+/**
+ * Projects one namespace's `entries` into the view shape: each built-in kind
+ * becomes a top-level slot (materialized empty if absent), and the remaining
+ * pack-contributed kinds sit under `.entries`. Shared by the single-namespace
+ * builder and the namespace-map builder.
+ */
+declare function promoteBuiltinKinds<TView>(entries: Readonly<Record<string, unknown>>, builtinKinds: readonly string[]): TView;
+/**
+ * Builds one namespace's entity view: promotes the given built-in kind slots to
+ * top-level for the default (`UNBOUND_NAMESPACE_ID`) namespace. Single-namespace
+ * targets (Mongo, SQLite) use this to unwrap their sole namespace to the root.
+ *
+ * Throws if the contract has no default (`UNBOUND_NAMESPACE_ID`) namespace.
+ */
+declare function buildSingleNamespaceView<TView>(storage: Storage, builtinKinds: readonly string[]): TView;
+/**
+ * Builds the namespace-keyed entity-view map (`{ <nsId>: SingleNamespaceView }`)
+ * for every namespace in the storage, keyed by raw namespace id. Mirrors
+ * `buildNamespacedEnums(domain)` — the storage-side twin.
+ */
+declare function buildNamespacedEntities<TMap>(storage: Storage, builtinKinds: readonly string[]): TMap;
+//#endregion
+//#region src/ir/domain.d.ts
+/**
+ * Lazy walk over every named domain entity in a {@link ApplicationDomain},
+ * yielded as {@link EntityCoordinate} tuples with `plane: 'domain'`.
+ *
+ * Same structural rules as {@link elementCoordinates} over storage: skip
+ * scalar `id`; each other object-valued property is an entity-kind slot.
+ */
+declare function domainElementCoordinates(domain: Pick<ApplicationDomain, 'namespaces'>): Generator<EntityCoordinate>;
+//#endregion
+//#region src/ir/entity-kind.d.ts
+interface EntityKindDescriptor<Input, Node> {
+  readonly kind: string;
+  readonly schema: Type<unknown>;
+  readonly construct: (input: Input) => Node;
+}
+type AnyEntityKindDescriptor = EntityKindDescriptor<never, unknown>;
+/**
+ * Hydrates a namespace's entities from raw JSON maps into IR class instances.
+ *
+ * For each kind in `entries`: if the descriptor map has a descriptor,
+ * construct each inner-map value; otherwise freeze-and-carry (`'carry'`)
+ * or throw naming the kind and nsId (`'fail'`).
+ *
+ * The single boundary cast hands `value` to `descriptor.construct` as its
+ * `Input`. The value satisfies the kind's `Input` either by the
+ * entries-input contract at authoring time or by prior `validateStorage`
+ * validation at hydration time.
+ */
+declare function hydrateNamespaceEntities(entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>, kinds: ReadonlyMap<string, AnyEntityKindDescriptor>, onUnknown: 'carry' | 'fail', nsId?: string): Record<string, Readonly<Record<string, unknown>>>;
+//#endregion
+//#region src/ir/storage-type.d.ts
+/**
+ * Framework-level alphabet for entries in a storage `types` slot.
+ *
+ * The slot is polymorphic at the framework level: a family or target can
+ * persist either a JSON-clean codec-triple object literal (carrying
+ * `kind: 'codec-instance'`) or a class-instance IR node with a narrower
+ * kind discriminator (e.g. `'<kind>'`). Hydration walkers,
+ * verifiers, and planners dispatch on the `kind` literal to recover the
+ * precise variant.
+ *
+ * The `kind` field is required at this layer (in contrast with
+ * `IRNode.kind` which is optional) because the slot's downstream
+ * consumers dispatch on it — without a guaranteed discriminator the
+ * polymorphic walk cannot pick the right reader. Concrete variants
+ * narrow `kind` to their literal and add their own field set;
+ * downstream consumers use `kind`-discriminator helpers to recover
+ * the precise shape.
+ */
+interface StorageType extends IRNode {
+  readonly kind: string;
+}
+//#endregion
+export { promoteBuiltinKinds as S, domainElementCoordinates as _, IRNode as a, freezeNode as b, NamespaceBase as c, Storage as d, StorageType as f, coordinateKey as g, buildSingleNamespaceView as h, EntityKindDescriptor as i, NamespacedEntities as l, buildNamespacedEntities as m, DefaultNamespaceEntries as n, IRNodeBase as o, UNBOUND_NAMESPACE_ID as p, EntityCoordinate as r, Namespace as s, AnyEntityKindDescriptor as t, SingleNamespaceView as u, elementCoordinates as v, hydrateNamespaceEntities as x, entityAt as y };
+//# sourceMappingURL=ir-BvE7L9FK.d.mts.map

package/dist/ir-BvE7L9FK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-BvE7L9FK.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/ir.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4CU;WACC;;uBAEY,sBAAsB;oBACzB;;;;;;;;;;;iBAWH,WAAW,UAAU,QAAQ,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;cA0B1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAiCJ,kBAAkB,QAAQ;WACzB;WACA,SAAS,SAAS,eAAe,SAAS;;;;;;;WAO1C;;uBAEY,sBAAsB,sBAAsB;oBAC/C;oBACA,SAAS,SAAS,eAAe,SAAS;oBAC1C;;;;;;MAMd;;;;;;;;;;;;;;;;;;;;UAoBI;WACC;WACA;WACA;WACA;;;;;;;;;;;;;iBAaM,mBAAmB,SAAS,KAAK,6BAA6B,UAAU;;;;;;;;;;;;;;iBAcxE,cAAc,YAAY,KAAK;;;;;;;iBAO/B,SAAS,aAAa,SAAS,KAAK,4BAA4B,OAAO,KAAK,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoCpJ,gBAAgB;WACf,YAAY,SAAS,eAAe;;;;;;;;;KAS1C,wBAAwB;WAClB;KACN,+BAA+B,cAAc;WACvC,eAAe;KACrB;;;;;;;;;;;;;;;;KAgBA,oBAAoB,UAAU,4CAA4C,KAAK,kBAAkB,gBAAgB,WAAW,YAAY,SAAS,MAAM;WACjJ,qBAAqB,KAAK,cAAc,UAAU,mDAAmD,YAAY,IAAI,SAAS;;;KAGpI,UAAU,cAAc;WAClB,eAAe;IACtB;;;;;;;;;;KAUC,mBAAmB;WACb;GACR,4CAA4C,YAAY,yBAAyB,oBAAoB,UAAU,uBAAuB,MAAM;;;;;;;iBAO9H,oBAAoB,OAAO,SAAS,SAAS,0BAA0B,kCAAkC;;;;;;;;iBAQzG,yBAAyB,OAAO,SAAS,SAAS,kCAAkC;;;;;;iBAMpF,wBAAwB,MAAM,SAAS,SAAS,kCAAkC;;;;;;;;;;iBAUlF,yBAAyB,QAAQ,KAAK,mCAAmC,UAAU;;;UAG1F,qBAAqB,OAAO;WAC3B;WACA,QAAQ;WACR,YAAY,OAAO,UAAU;;KAEnC,0BAA0B;;;;;;;;;;;;;iBAad,yBAAyB,SAAS,SAAS,eAAe,SAAS,4BAA4B,OAAO,oBAAoB,0BAA0B,6BAA6B,gBAAgB,eAAe,SAAS;;;;;;;;;;;;;;;;;;;;;UAqBhO,oBAAoB;WACnB"}