@prisma-next/contract 0.13.0-dev.9 → 0.14.0-dev.1

package/src/enum-accessor.ts

@@ -0,0 +1,191 @@
+import type { Contract } from './contract-types';
+import type { ContractEnum } from './domain-types';
+import type { JsonValue } from './types';
+
+/**
+ * Runtime view of a domain enum, built at the client from the emitted
+ * `ContractEnum` JSON (codec-encoded `JsonValue` members, literal types erased).
+ *
+ * This deliberately mirrors the accessor shape of the authoring-time
+ * `EnumTypeHandle` (in `contract-ts`) rather than reusing it: that handle carries
+ * the literal value generics and lives in the authoring layer, which the
+ * foundation layer cannot depend on. The two are the same surface seen from the
+ * two planes — authoring (typed) and runtime (validated JSON).
+ */
+export interface EnumAccessor {
+  readonly values: readonly JsonValue[];
+  readonly names: readonly string[];
+  readonly members: Readonly<Record<string, JsonValue>>;
+  has(v: JsonValue): boolean;
+  hasName(name: string): boolean;
+  nameOf(v: JsonValue): string | undefined;
+  ordinalOf(v: JsonValue): number;
+}
+
+export function createEnumAccessor(contractEnum: ContractEnum): EnumAccessor {
+  const values = Object.freeze(contractEnum.members.map((m) => m.value));
+  const names = Object.freeze(contractEnum.members.map((m) => m.name));
+  const members: Readonly<Record<string, JsonValue>> = Object.freeze(
+    Object.fromEntries(contractEnum.members.map((m) => [m.name, m.value])),
+  );
+
+  const valueSet = new Set(values);
+  const nameSet = Object.freeze(new Set(names));
+  const valueToName = new Map(contractEnum.members.map((m) => [m.value, m.name]));
+  const valueToOrdinal = new Map(values.map((v, i) => [v, i]));
+
+  return {
+    values,
+    names,
+    members,
+    has: (v: JsonValue) => valueSet.has(v),
+    hasName: (name: string) => nameSet.has(name),
+    nameOf: (v: JsonValue) => valueToName.get(v),
+    ordinalOf: (v: JsonValue) => valueToOrdinal.get(v) ?? -1,
+  };
+}
+
+/**
+ * Build the enum-accessor map for a single namespace, keyed by enum name.
+ * Each namespace facet exposes only its own enums — the IR keys enums under
+ * `domain.namespaces[ns].enum`, so the same name in two namespaces resolves
+ * independently rather than colliding in one flat map.
+ */
+export function buildEnumsMapForNamespace(
+  domain: {
+    readonly namespaces: Readonly<
+      Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>
+    >;
+  },
+  namespaceId: string,
+): Record<string, EnumAccessor> {
+  const result: Record<string, EnumAccessor> = {};
+  const namespace = domain.namespaces[namespaceId];
+  if (namespace?.enum) {
+    for (const [name, contractEnum] of Object.entries(namespace.enum)) {
+      result[name] = createEnumAccessor(contractEnum);
+    }
+  }
+  return result;
+}
+
+/**
+ * Build the enum-accessor map for every namespace of a domain, keyed by
+ * namespace id then enum name. This is the lane-agnostic enum surface the
+ * `db.enums` facade member exposes: enums are contract metadata, the same
+ * whether reached through the sql lane or the orm lane, so the facade builds
+ * this once and projects it per target.
+ */
+export function buildNamespacedEnums(domain: {
+  readonly namespaces: Readonly<
+    Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>
+  >;
+}): Record<string, Record<string, EnumAccessor>> {
+  const result: Record<string, Record<string, EnumAccessor>> = {};
+  for (const namespaceId of Object.keys(domain.namespaces)) {
+    result[namespaceId] = buildEnumsMapForNamespace(domain, namespaceId);
+  }
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Type-level projection of the namespaced enum surface.
+//
+// These types derive the literal-preserving accessor shape from the contract,
+// hung off the `db.enums` facade map (`db.enums.<ns>.<Name>`). They are the
+// same accessors the runtime builds above, but typed from the two emission
+// paths:
+//   - Emitted contracts carry the literal enum entries under
+//     `domain.namespaces[ns].enum`; each maps to a `ContractEnumAccessor`.
+//   - The no-emit (built) contract carries them flat on `enumAccessors`
+//     (already accessor-shaped, literal-preserving), since its built domain
+//     type does not narrow `namespaces[ns].enum`. All authored enums land in
+//     the single built namespace, so exposing the flat map per namespace is
+//     correct there.
+// Only `SqlContractResult` carries `enumAccessors`; emitted contracts never
+// do, so the two carriers never overlap.
+// ---------------------------------------------------------------------------
+
+type Present<T> = Exclude<T, undefined>;
+
+// A domain enum entry as carried in `domain.namespaces[ns].enum[name]`: an
+// ordered member tuple. The no-emit (built) path preserves the literal member
+// values so the derived accessor keeps its literal `values`/`names`/`members`.
+type EnumMemberEntry = { readonly name: string; readonly value: JsonValue };
+type EnumEntry = { readonly members: readonly EnumMemberEntry[] };
+
+type EnumEntryValues<Entry extends EnumEntry> = {
+  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry
+    ? Entry['members'][I]['value']
+    : never;
+};
+
+type EnumEntryNames<Entry extends EnumEntry> = {
+  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry
+    ? Entry['members'][I]['name']
+    : never;
+};
+
+type EnumEntryMembers<Entry extends EnumEntry> = {
+  readonly [M in Entry['members'][number] as M['name']]: M['value'];
+};
+
+// The runtime accessor shape for one enum, with literal `values`/`names`/
+// `members` derived from the entry's member tuple. Mirrors `EnumAccessor`'s
+// runtime surface and the authoring `EnumTypeHandle` accessor.
+export type ContractEnumAccessor<Entry extends EnumEntry> = {
+  readonly values: EnumEntryValues<Entry>;
+  readonly names: EnumEntryNames<Entry>;
+  readonly members: EnumEntryMembers<Entry>;
+  /** Returns true and narrows `v` to the enum's value union when `v` is a declared member value. */
+  has(v: JsonValue): v is EnumEntryValues<Entry>[number];
+  /** Returns true and narrows `name` to the enum's member-name union when `name` is a declared member name. */
+  hasName(name: string): name is Extract<EnumEntryNames<Entry>[number], string>;
+  nameOf(v: EnumEntryValues<Entry>[number]): string | undefined;
+  ordinalOf(v: EnumEntryValues<Entry>[number]): number;
+};
+
+/**
+ * The value union for a `ContractEnumAccessor`.
+ * Use in function signatures to accept any declared enum value without re-exporting
+ * the member type alias from the accessor's generic entry.
+ */
+export type EnumValues<A> = A extends { readonly values: ReadonlyArray<infer V> } ? V : never;
+
+/**
+ * The member-name union for a `ContractEnumAccessor`.
+ */
+export type EnumMemberNames<A> = A extends { readonly names: ReadonlyArray<infer N> } ? N : never;
+
+type EnumEntriesToAccessors<Enums> = {
+  readonly [K in keyof Enums]: Enums[K] extends EnumEntry ? ContractEnumAccessor<Enums[K]> : never;
+};
+
+type BuiltEnumAccessorsOf<TContract> = TContract extends {
+  readonly enumAccessors: infer A;
+}
+  ? A
+  : Record<never, never>;
+
+type NamespaceEnumEntries<TNamespace> = TNamespace extends {
+  readonly enum?: infer E;
+}
+  ? unknown extends E
+    ? Record<never, never>
+    : Present<E>
+  : Record<never, never>;
+
+// The per-namespace enum accessors. Each namespace exposes only its own enums
+// (the IR's `domain.namespaces[ns].enum`), so the same enum name in two
+// namespaces resolves to each namespace's own accessor.
+export type NamespaceEnumAccessors<
+  TContract extends Contract,
+  NsId extends keyof TContract['domain']['namespaces'],
+> = EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>> &
+  BuiltEnumAccessorsOf<TContract>;
+
+// The lane-agnostic enum surface exposed on the `db.enums` facade member: a
+// namespace-keyed map projected per target exactly like `db.sql` / `db.orm`.
+export type NamespacedEnums<TContract extends Contract> = {
+  readonly [Ns in keyof TContract['domain']['namespaces']]: NamespaceEnumAccessors<TContract, Ns>;
+};

package/src/exports/enum-accessor.ts

@@ -0,0 +1,13 @@
+export type {
+  ContractEnumAccessor,
+  EnumAccessor,
+  EnumMemberNames,
+  EnumValues,
+  NamespacedEnums,
+  NamespaceEnumAccessors,
+} from '../enum-accessor';
+export {
+  buildEnumsMapForNamespace,
+  buildNamespacedEnums,
+  createEnumAccessor,
+} from '../enum-accessor';

package/src/exports/is-plain-record.ts

@@ -0,0 +1 @@
+export { isPlainRecord } from '../is-plain-record';

package/src/exports/types.ts

@@ -1,7 +1,6 @@
 export type {
   Contract,
   ContractExecutionSection,
-  ContractModelDefinitions,
   ContractValueObjectDefinitions,
 } from '../contract-types';
 export { DomainNamespaceResolutionError } from '../contract-validation-error';

package/src/hashing.ts

@@ -8,14 +8,11 @@ import {
   type StorageSort,
 } from './canonicalization';
 import type { Contract } from './contract-types';
+import { isPlainRecord } from './is-plain-record';
 import type { ExecutionHashBase, ProfileHashBase, StorageHashBase } from './types';
 
 const SCHEMA_VERSION = '1';
 
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
 // Storage hashes fingerprint table/column layout, not which target pack emitted a
 // namespace. Persisted contract.json carries namespace `kind` discriminators;
 // authoring-time hashes never included them (IR `kind` is non-enumerable).

package/src/is-plain-record.ts

@@ -0,0 +1,11 @@
+/**
+ * Strict plain-object guard: accepts only objects with `Object.prototype`
+ * or `null` as their prototype. Rejects arrays, class instances, and other
+ * non-plain objects. Used to distinguish raw-data records from IR class
+ * instances in validation and hydration paths.
+ */
+export function isPlainRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const proto: unknown = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}

package/src/types.ts

@@ -173,7 +173,7 @@ export function isExecutionMutationDefaultValue(
 }
 
 export type ExecutionMutationDefault = {
-  readonly ref: { readonly table: string; readonly column: string };
+  readonly ref: { readonly namespace: string; readonly table: string; readonly column: string };
   readonly onCreate?: ExecutionMutationDefaultValue;
   readonly onUpdate?: ExecutionMutationDefaultValue;
 };

package/src/value-set-ref.ts

@@ -1,26 +1,31 @@
 /**
- * Space-aware reference coordinate for a domain enum or storage value-set.
+ * Entity coordinate for a domain enum or storage value-set reference.
  *
- * `plane` names the contract plane the referenced entity lives in:
- * - `'domain'` — the entity lives in the domain plane's `enum` slot.
- * - `'storage'` — the entity lives in the storage plane's `valueSet` slot.
+ * Field-name identity with the framework's `EntityCoordinate` type
+ * (packages/1-framework/1-core/framework-components/src/ir/storage.ts).
+ * Foundation-contract cannot import framework-components (dependency points
+ * the other way), so this is a standalone mirror of that shape plus the
+ * cross-space discriminator.
  *
- * `entityKind` names the source entity-kind:
- * - `'enum'` — the referenced entity is a domain enum.
- * - `'value-set'` — the referenced entity is a storage value-set.
+ * One-vocabulary rule (ADR 224): `entityKind` is equal to the entries slot
+ * key the referenced entity lives under — `'enum'` for domain's `enum` slot,
+ * `'valueSet'` for storage's `entries.valueSet` slot. No consumer-side
+ * translation between the kind string and the slot key.
  *
- * `namespaceId` admits the `UNBOUND_NAMESPACE_ID` (`__unbound__`) sentinel for
- * single-namespace (unbound) references.
+ * Every `valueSet` reference is intra-plane (domain field → domain enum;
+ * storage column/check → storage value-set). The directional invariant:
+ * domain may reference storage; storage may never reference domain.
  *
- * Cross-space discrimination is presence-based: when `spaceId` is absent the
- * reference is local (same contract-space); when `spaceId` is present the
- * reference is cross-space. This mirrors the `ForeignKeyReference` carrier
- * convention — no separate tag field — so local refs are JSON-minimal.
+ * `namespaceId` admits the `UNBOUND_NAMESPACE_ID` (`__unbound__`) sentinel
+ * for single-namespace (unbound) references.
+ *
+ * `spaceId` is the cross-space discriminator: absent ⇒ local (same
+ * contract-space); present ⇒ cross-space. No separate tag field.
  */
 export interface ValueSetRef {
   readonly plane: 'domain' | 'storage';
   readonly namespaceId: string;
-  readonly entityKind: 'enum' | 'value-set';
-  readonly name: string;
+  readonly entityKind: 'enum' | 'valueSet';
+  readonly entityName: string;
   readonly spaceId?: string;
 }

package/dist/contract-types-CBbD-VV1.d.mts

@@ -1,271 +0,0 @@
-import { E as CrossReference, _ as ContractValueObject, d as ContractModelBase, t as ApplicationDomain } from "./domain-envelope-OkWsysCY.mjs";
-
-//#region src/control-policy.d.ts
-/**
- * Governance posture for a storage-plane node or for the contract as a whole.
- *
- * - `managed`  — Prisma Next owns the full lifecycle (DDL, migrations, verification).
- * - `tolerated` — node was found in the database but is not schema-managed; Prisma Next
- *   leaves it untouched while tracking its existence.
- * - `external` — node is owned by an external system; Prisma Next never emits DDL for it.
- * - `observed` — read-only access; Prisma Next does not write to or migrate the node.
- */
-type ControlPolicy = 'managed' | 'tolerated' | 'external' | 'observed';
-/**
- * Resolves the effective control policy for a storage-plane node.
- *
- * Precedence: node-level value → contract default → `'managed'`.
- *
- * Both parameters are optional raw values so this function stays node-type-agnostic
- * and can be called by any consumer (verifier, planner, etc.) without importing IR classes.
- */
-declare function effectiveControlPolicy(nodeControl: ControlPolicy | undefined, defaultControlPolicy: ControlPolicy | undefined): ControlPolicy;
-//#endregion
-//#region src/types.d.ts
-/**
- * Unique symbol used as the key for branding types.
- */
-declare const $: unique symbol;
-/**
- * A helper type to brand a given type with a unique identifier.
- *
- * @template TKey Text used as the brand key.
- * @template TValue Optional value associated with the brand key. Defaults to `true`.
- */
-type Brand<TKey extends string | number | symbol, TValue = true> = {
-  [$]: { [K in TKey]: TValue };
-};
-/**
- * Base type for storage contract hashes.
- * Emitted contract.d.ts files use this with the hash value as a type parameter:
- * `type StorageHash = StorageHashBase<'sha256:abc123...'>`
- */
-type StorageHashBase<THash extends string> = THash & Brand<'StorageHash'>;
-/**
- * Base type for execution contract hashes.
- * Emitted contract.d.ts files use this with the hash value as a type parameter:
- * `type ExecutionHash = ExecutionHashBase<'sha256:def456...'>`
- */
-type ExecutionHashBase<THash extends string> = THash & Brand<'ExecutionHash'>;
-declare function executionHash<const T extends string>(value: T): ExecutionHashBase<T>;
-declare function coreHash<const T extends string>(value: T): StorageHashBase<T>;
-/**
- * Base type for profile contract hashes.
- * Emitted contract.d.ts files use this with the hash value as a type parameter:
- * `type ProfileHash = ProfileHashBase<'sha256:def456...'>`
- */
-type ProfileHashBase<THash extends string> = THash & Brand<'ProfileHash'>;
-declare function profileHash<const T extends string>(value: T): ProfileHashBase<T>;
-/**
- * One entity-kind slot in a namespace — a map of entity name to entry.
- * Values are opaque at the foundation layer; family and target concretions
- * refine them to typed IR classes.
- */
-type StorageEntitySlot = Readonly<Record<string, unknown>>;
-/**
- * Plain-data namespace entry in a storage block. Every hydrated contract
- * carries at least `id` plus entity-kind slot maps under `entries`
- * (`table`, `collection`, …). Foundation declares only this shape — no IR
- * machinery.
- */
-interface StorageNamespace {
-  readonly id: string;
-  readonly entries: Readonly<Record<string, StorageEntitySlot>>;
-}
-/**
- * Base type for family-specific storage blocks.
- * Family storage types (SqlStorage, MongoStorage, etc.) extend this to carry the
- * storage hash alongside family-specific data (tables, collections, etc.).
- *
- * The `namespaces` map is carried by every hydrated storage block. Serialized
- * envelope shape is target-owned; this types the in-memory contract after
- * `deserializeContract`.
- */
-interface StorageBase<THash extends string = string> {
-  readonly storageHash: StorageHashBase<THash>;
-  readonly namespaces: Readonly<Record<string, StorageNamespace>>;
-}
-interface FieldType {
-  readonly type: string;
-  readonly nullable: boolean;
-  readonly items?: FieldType;
-  readonly properties?: Record<string, FieldType>;
-}
-type GeneratedValueSpec = {
-  readonly id: string;
-  readonly params?: Record<string, unknown>;
-};
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | {
-  readonly [key: string]: JsonValue;
-} | readonly JsonValue[];
-type ColumnDefaultLiteralValue = JsonValue;
-type ColumnDefaultLiteralInputValue = ColumnDefaultLiteralValue | Date;
-/**
- * Runtime predicate for `ColumnDefaultLiteralInputValue`. Authoring layers
- * resolve template values from caller-supplied args (typed `unknown` at the
- * boundary) and need to validate before constructing a `ColumnDefault`.
- * Accepts JSON primitives, plain arrays/objects of JSON values, and `Date`
- * instances. Rejects functions, class instances (other than `Date`),
- * `undefined`, `bigint`, `symbol`, and arrays/objects containing those.
- */
-declare function isColumnDefaultLiteralInputValue(value: unknown): value is ColumnDefaultLiteralInputValue;
-type ColumnDefault = {
-  readonly kind: 'literal';
-  readonly value: ColumnDefaultLiteralInputValue;
-} | {
-  readonly kind: 'function';
-  readonly expression: string;
-};
-declare function isColumnDefault(value: unknown): value is ColumnDefault;
-type ExecutionMutationDefaultValue = {
-  readonly kind: 'generator';
-  readonly id: GeneratedValueSpec['id'];
-  readonly params?: Record<string, unknown>;
-};
-declare function isExecutionMutationDefaultValue(value: unknown): value is ExecutionMutationDefaultValue;
-type ExecutionMutationDefault = {
-  readonly ref: {
-    readonly table: string;
-    readonly column: string;
-  };
-  readonly onCreate?: ExecutionMutationDefaultValue;
-  readonly onUpdate?: ExecutionMutationDefaultValue;
-};
-/**
- * `ExecutionMutationDefault` minus its `ref` — the per-field phases value
- * authoring layers attach to a column before the column ref is known.
- */
-type ExecutionMutationDefaultPhases = Omit<ExecutionMutationDefault, 'ref'>;
-type ExecutionSection<THash extends string = string> = {
-  readonly executionHash: ExecutionHashBase<THash>;
-  readonly mutations: {
-    readonly defaults: ReadonlyArray<ExecutionMutationDefault>;
-  };
-};
-interface Source {
-  readonly readOnly: boolean;
-  readonly projection: Record<string, FieldType>;
-  readonly origin?: Record<string, unknown>;
-  readonly capabilities?: Record<string, boolean>;
-}
-interface DocIndex {
-  readonly name: string;
-  readonly keys: Record<string, 'asc' | 'desc'>;
-  readonly unique?: boolean;
-  readonly where?: Expr;
-}
-type Expr = {
-  readonly kind: 'eq';
-  readonly path: ReadonlyArray<string>;
-  readonly value: unknown;
-} | {
-  readonly kind: 'exists';
-  readonly path: ReadonlyArray<string>;
-};
-interface DocCollection {
-  readonly name: string;
-  readonly id?: {
-    readonly strategy: 'auto' | 'client' | 'uuid' | 'objectId';
-  };
-  readonly fields: Record<string, FieldType>;
-  readonly indexes?: ReadonlyArray<DocIndex>;
-  readonly readOnly?: boolean;
-}
-interface PlanMeta {
-  readonly target: string;
-  readonly targetFamily?: string;
-  readonly storageHash: string;
-  readonly profileHash?: string;
-  readonly lane: string;
-  readonly annotations?: {
-    readonly [key: string]: unknown;
-  };
-}
-/**
- * Contract marker record stored in the database.
- * Represents the current contract identity for a database.
- */
-interface ContractMarkerRecord {
-  readonly storageHash: string;
-  readonly profileHash: string;
-  readonly contractJson: unknown | null;
-  readonly canonicalVersion: number | null;
-  readonly updatedAt: Date;
-  readonly appTag: string | null;
-  readonly meta: Record<string, unknown>;
-  readonly invariants: readonly string[];
-}
-/**
- * One applied migration edge from the per-space ledger journal.
- * Returned by `readLedger` in append (apply) order.
- */
-interface LedgerEntryRecord {
-  readonly space: string;
-  readonly migrationName: string;
-  readonly migrationHash: string;
-  readonly from: string | null;
-  readonly to: string;
-  readonly appliedAt: Date;
-  readonly operationCount: number;
-}
-//#endregion
-//#region src/contract-types.d.ts
-/**
- * Execution section for the unified contract (ADR 182).
- *
- * Unlike the legacy {@link import('./types').ExecutionSection}, this type
- * requires `executionHash` — when an execution section is present, its
- * hash must be too (consistent with `StorageBase.storageHash`).
- *
- * @template THash  Literal hash string type for type-safe hash tracking.
- */
-type ContractExecutionSection<THash extends string = string> = {
-  readonly executionHash: ExecutionHashBase<THash>;
-  readonly mutations: {
-    readonly defaults: ReadonlyArray<ExecutionMutationDefault>;
-  };
-};
-/**
- * Unified contract representation (ADR 182).
- *
- * A `Contract` is the canonical in-memory representation of a data contract.
- * It is model-first (domain models carry their own storage bridge) and
- * family-parameterized (SQL, Mongo, etc. specialize via `TStorage` and model
- * storage generics on `ContractModel`).
- *
- * JSON persistence fields (`schemaVersion`, `sources`) are not represented
- * here — they are handled at the serialization boundary.
- *
- * @template TStorage  Family-specific storage block (extends {@link StorageBase}).
- * @template TModels   Record of model name → {@link ContractModel} with
- *                     family-specific model storage.
- */
-interface Contract<TStorage extends StorageBase = StorageBase, TModels extends Record<string, ContractModelBase> = Record<string, ContractModelBase>> {
-  readonly target: string;
-  readonly targetFamily: string;
-  readonly roots: Record<string, CrossReference>;
-  /**
-   * Application plane (ADR 221): `domain.namespaces.<nsId>.{ models, valueObjects }`.
-   * `TModels` types the union of model entries across namespaces for family DSL inference.
-   */
-  readonly domain: ApplicationDomain<TModels>;
-  readonly storage: TStorage;
-  readonly capabilities: Record<string, Record<string, boolean>>;
-  readonly extensionPacks: Record<string, unknown>;
-  readonly execution?: ContractExecutionSection;
-  readonly profileHash: ProfileHashBase<string>;
-  readonly meta: Record<string, unknown>;
-  readonly defaultControlPolicy?: ControlPolicy;
-}
-/** Model definitions union carried on a {@link Contract}'s `TModels` type parameter. */
-type ContractModelDefinitions<TContract extends Contract> = TContract extends Contract<StorageBase, infer TModels> ? TModels : never;
-type ExactlyOneNamespace<T extends Record<string, unknown>> = keyof T extends infer Only extends keyof T ? [keyof T] extends [Only] ? Only : never : never;
-type NamespaceValueObjectsOf<TNamespace> = TNamespace extends {
-  readonly valueObjects?: infer VO;
-} ? VO extends Record<string, ContractValueObject> ? VO : Record<never, never> : Record<never, never>;
-/** Value-object map when the contract declares exactly one domain namespace. */
-type ContractValueObjectDefinitions<TContract extends Contract> = NamespaceValueObjectsOf<TContract['domain']['namespaces'][ExactlyOneNamespace<TContract['domain']['namespaces']>]> extends infer Projected ? Projected extends Record<string, ContractValueObject> ? Projected : Record<never, never> : Record<never, never>;
-//#endregion
-export { StorageNamespace as A, LedgerEntryRecord as C, StorageBase as D, Source as E, isExecutionMutationDefaultValue as F, profileHash as I, ControlPolicy as L, executionHash as M, isColumnDefault as N, StorageEntitySlot as O, isColumnDefaultLiteralInputValue as P, effectiveControlPolicy as R, JsonValue as S, ProfileHashBase as T, ExecutionSection as _, $ as a, GeneratedValueSpec as b, ColumnDefaultLiteralInputValue as c, DocCollection as d, DocIndex as f, ExecutionMutationDefaultValue as g, ExecutionMutationDefaultPhases as h, ContractValueObjectDefinitions as i, coreHash as j, StorageHashBase as k, ColumnDefaultLiteralValue as l, ExecutionMutationDefault as m, ContractExecutionSection as n, Brand as o, ExecutionHashBase as p, ContractModelDefinitions as r, ColumnDefault as s, Contract as t, ContractMarkerRecord as u, Expr as v, PlanMeta as w, JsonPrimitive as x, FieldType as y };
-//# sourceMappingURL=contract-types-CBbD-VV1.d.mts.map

package/dist/contract-types-CBbD-VV1.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-types-CBbD-VV1.d.mts","names":[],"sources":["../src/control-policy.ts","../src/types.ts","../src/contract-types.ts"],"mappings":"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"}