@prisma-next/contract 0.12.0 → 0.13.0-dev.2

package/src/contract-types.ts

@@ -1,3 +1,4 @@
+import type { ControlPolicy } from './control-policy';
 import type { CrossReference } from './cross-reference';
 import type { ApplicationDomain } from './domain-envelope';
 import type { ContractModelBase, ContractValueObject } from './domain-types';
@@ -57,12 +58,15 @@ export interface Contract<
   readonly execution?: ContractExecutionSection;
   readonly profileHash: ProfileHashBase<string>;
   readonly meta: Record<string, unknown>;
+  readonly defaultControlPolicy?: ControlPolicy;
 }
 
-export type ContractModelsMap<TContract extends Contract> =
+/** Model definitions union carried on a {@link Contract}'s `TModels` type parameter. */
+export type ContractModelDefinitions<TContract extends Contract> =
   TContract extends Contract<StorageBase, infer TModels> ? TModels : never;
 
-type ExactlyOneKey<T extends Record<string, unknown>> = keyof T extends infer Only extends keyof T
+type ExactlyOneNamespace<T extends Record<string, unknown>> = keyof T extends infer Only extends
+  keyof T
   ? [keyof T] extends [Only]
     ? Only
     : never
@@ -76,10 +80,10 @@ type NamespaceValueObjectsOf<TNamespace> = TNamespace extends {
     : Record<never, never>
   : Record<never, never>;
 
-/** Value-object map for the contract's sole domain namespace (type-level single-namespace projection). */
-export type ContractValueObjectsMap<TContract extends Contract> =
+/** Value-object map when the contract declares exactly one domain namespace. */
+export type ContractValueObjectDefinitions<TContract extends Contract> =
   NamespaceValueObjectsOf<
-    TContract['domain']['namespaces'][ExactlyOneKey<TContract['domain']['namespaces']>]
+    TContract['domain']['namespaces'][ExactlyOneNamespace<TContract['domain']['namespaces']>]
   > extends infer Projected
     ? Projected extends Record<string, ContractValueObject>
       ? Projected

package/src/control-policy.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+export 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.
+ */
+export function effectiveControlPolicy(
+  nodeControl: ControlPolicy | undefined,
+  defaultControlPolicy: ControlPolicy | undefined,
+): ControlPolicy {
+  return nodeControl ?? defaultControlPolicy ?? 'managed';
+}

package/src/cross-reference.ts

@@ -5,16 +5,23 @@ import { asNamespaceId, type NamespaceId } from './namespace-id';
 export interface CrossReference {
   readonly namespace: NamespaceId;
   readonly model: string;
+  /**
+   * Contract-space identity for cross-space relations. When present, the
+   * referenced model lives in a different contract space. Absent for local
+   * (same-space) relations.
+   */
+  readonly space?: string;
 }
 
-export const CrossReferenceSchema = blindCast<
+export const CrossReferenceSchema = /* @__PURE__ */ blindCast<
   Type<CrossReference>,
   'namespace is validated as string at runtime and branded to NamespaceId by asNamespaceId in crossRef(); the schema accepts plain strings but the public type reflects the branded shape'
 >(
-  type({
+  /* @__PURE__ */ type({
     '+': 'reject',
     namespace: 'string',
     model: 'string',
+    'space?': 'string',
   }),
 );
 
@@ -23,6 +30,11 @@ const DEFAULT_CROSS_REF_NAMESPACE = '__unbound__';
 export function crossRef(
   model: string,
   namespace: string = DEFAULT_CROSS_REF_NAMESPACE,
+  space?: string,
 ): CrossReference {
-  return { namespace: asNamespaceId(namespace), model };
+  return {
+    namespace: asNamespaceId(namespace),
+    model,
+    ...(space !== undefined ? { space } : {}),
+  };
 }

package/src/default-namespace.ts

@@ -0,0 +1,36 @@
+import { DomainNamespaceResolutionError } from './contract-validation-error';
+
+/**
+ * Reserved sentinel domain namespace id for the late-bound application-domain
+ * slot — the namespace a model lands in when it is authored without an explicit
+ * namespace. This is target-agnostic: targets that allow un-namespaced
+ * authoring (e.g. Mongo, SQLite) declare this id as their default on the target
+ * descriptor; the framework names the sentinel, never a target. Mirrors
+ * storage's `UNBOUND_NAMESPACE_ID` on the domain plane.
+ */
+export const UNBOUND_DOMAIN_NAMESPACE_ID = '__unbound__' as const;
+
+/**
+ * Resolve the single domain namespace of a single-namespace contract.
+ *
+ * Bare-name access (`db.User`) reads "the contract's one namespace". Every
+ * contract in scope today declares exactly one domain namespace, so this is
+ * exact — there is nothing to infer. A contract that declares more than one
+ * namespace is ambiguous for a bare name, so rather than silently pick one this
+ * throws; cross-namespace selection is made explicit (TML-2550).
+ */
+export function soleDomainNamespaceId(domain: {
+  readonly namespaces: Readonly<Record<string, unknown>>;
+}): string {
+  const [soleNamespaceId, ...rest] = Object.keys(domain.namespaces);
+  if (soleNamespaceId === undefined) {
+    throw new DomainNamespaceResolutionError('domain has no namespaces');
+  }
+  if (rest.length > 0) {
+    const all = [soleNamespaceId, ...rest];
+    throw new DomainNamespaceResolutionError(
+      `bare-name resolution requires exactly one domain namespace, found ${all.length} (${all.join(', ')}); select a namespace explicitly`,
+    );
+  }
+  return soleNamespaceId;
+}

package/src/domain-envelope.ts

@@ -1,7 +1,6 @@
-import { DomainNamespaceResolutionError } from './contract-validation-error';
-import type { ContractModelBase, ContractValueObject } from './domain-types';
+import type { ContractEnum, ContractModelBase, ContractValueObject } from './domain-types';
 
-export const UNBOUND_DOMAIN_NAMESPACE_ID = '__unbound__' as const;
+export { UNBOUND_DOMAIN_NAMESPACE_ID } from './default-namespace';
 
 /**
  * One namespace's application-domain entities — models and optional value
@@ -12,6 +11,7 @@ export interface ApplicationDomainNamespace<
 > {
   readonly models: TModels;
   readonly valueObjects?: Record<string, ContractValueObject>;
+  readonly enum?: Record<string, ContractEnum>;
 }
 
 /**
@@ -27,61 +27,3 @@ export interface ApplicationDomain<
 export type ContractWithDomain = {
   readonly domain: ApplicationDomain;
 };
-
-export function resolveSingleDomainNamespaceId(
-  domain: ApplicationDomain,
-  namespaceId?: string,
-): string {
-  if (namespaceId !== undefined) {
-    if (!Object.hasOwn(domain.namespaces, namespaceId)) {
-      throw new DomainNamespaceResolutionError(
-        `domain namespace "${namespaceId}" is not present on the contract`,
-      );
-    }
-    return namespaceId;
-  }
-
-  const namespaceIds = Object.keys(domain.namespaces);
-  if (namespaceIds.length === 0) {
-    throw new DomainNamespaceResolutionError('domain has no namespaces');
-  }
-  if (namespaceIds.length > 1) {
-    throw new DomainNamespaceResolutionError(
-      `expected exactly one domain namespace, found ${namespaceIds.length} (${namespaceIds.join(', ')})`,
-    );
-  }
-  const [soleNamespaceId] = namespaceIds;
-  if (soleNamespaceId === undefined) {
-    throw new DomainNamespaceResolutionError('domain has no namespaces');
-  }
-  return soleNamespaceId;
-}
-
-// Transitional single-namespace projection; pending runtime-qualification slice.
-export function contractModels<TModels extends Record<string, ContractModelBase>>(
-  contract: { readonly domain: ApplicationDomain<TModels> },
-  namespaceId?: string,
-): TModels {
-  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
-  const domainNamespace = contract.domain.namespaces[resolved];
-  if (domainNamespace === undefined) {
-    throw new DomainNamespaceResolutionError(
-      `domain namespace "${resolved}" is not present on the contract`,
-    );
-  }
-  return domainNamespace.models;
-}
-
-export function contractValueObjects<TModels extends Record<string, ContractModelBase>>(
-  contract: { readonly domain: ApplicationDomain<TModels> },
-  namespaceId?: string,
-): Record<string, ContractValueObject> | undefined {
-  const resolved = resolveSingleDomainNamespaceId(contract.domain, namespaceId);
-  const domainNamespace = contract.domain.namespaces[resolved];
-  if (domainNamespace === undefined) {
-    throw new DomainNamespaceResolutionError(
-      `domain namespace "${resolved}" is not present on the contract`,
-    );
-  }
-  return domainNamespace.valueObjects;
-}

package/src/domain-namespace-access.ts

@@ -0,0 +1,32 @@
+import { DomainNamespaceResolutionError } from './contract-validation-error';
+import { soleDomainNamespaceId } from './default-namespace';
+import type { ApplicationDomain } from './domain-envelope';
+import type { ContractModelBase, ContractValueObject } from './domain-types';
+
+/**
+ * Models map for the contract's single domain namespace. Throws when the
+ * contract does not declare exactly one namespace — bare-name access is
+ * ambiguous across namespaces and must be qualified explicitly (TML-2550).
+ */
+export function domainModelsAtDefaultNamespace<TModels extends Record<string, ContractModelBase>>(
+  domain: ApplicationDomain<TModels>,
+): TModels {
+  const namespaceId = soleDomainNamespaceId(domain);
+  const domainNamespace = domain.namespaces[namespaceId];
+  if (domainNamespace === undefined) {
+    throw new DomainNamespaceResolutionError(
+      `domain namespace "${namespaceId}" is not present on the contract`,
+    );
+  }
+  return domainNamespace.models;
+}
+
+/**
+ * Value objects for the contract's single domain namespace, when present.
+ * Throws when the contract does not declare exactly one namespace.
+ */
+export function domainValueObjectsAtDefaultNamespace<
+  TModels extends Record<string, ContractModelBase>,
+>(domain: ApplicationDomain<TModels>): Record<string, ContractValueObject> | undefined {
+  return domain.namespaces[soleDomainNamespaceId(domain)]?.valueObjects;
+}

package/src/domain-types.ts

@@ -1,4 +1,5 @@
 import type { CrossReference } from './cross-reference';
+import type { ValueSetRef } from './value-set-ref';
 
 export type ScalarFieldType = {
   readonly kind: 'scalar';
@@ -23,6 +24,17 @@ export type ContractField = {
   readonly type: ContractFieldType;
   readonly many?: true;
   readonly dict?: true;
+  readonly valueSet?: ValueSetRef;
+};
+
+/**
+ * A domain enum: an ordered set of named members, each with a codec-encoded
+ * value. The `codecId` identifies the codec used to encode member values in
+ * storage. The `members` array is ordered (declaration order is preserved).
+ */
+export type ContractEnum = {
+  readonly codecId: string;
+  readonly members: readonly { readonly name: string; readonly value: string }[];
 };
 
 export type ContractRelationOn = {
@@ -30,12 +42,30 @@ export type ContractRelationOn = {
   readonly targetFields: readonly string[];
 };
 
-export type ContractReferenceRelation = {
+export type ContractRelationThrough = {
+  readonly table: string;
+  readonly namespaceId: string;
+  readonly parentColumns: readonly string[];
+  readonly childColumns: readonly string[];
+  readonly targetColumns: readonly string[];
+};
+
+export type ContractManyToManyRelation = {
+  readonly to: CrossReference;
+  readonly cardinality: 'N:M';
+  readonly on: ContractRelationOn;
+  readonly through: ContractRelationThrough;
+};
+
+export type ContractNonJunctionRelation = {
   readonly to: CrossReference;
   readonly cardinality: '1:1' | '1:N' | 'N:1';
   readonly on: ContractRelationOn;
+  readonly through?: never;
 };
 
+export type ContractReferenceRelation = ContractManyToManyRelation | ContractNonJunctionRelation;
+
 export type ContractEmbedRelation = {
   readonly to: CrossReference;
   readonly cardinality: '1:1' | '1:N';

package/src/exports/apply-specifier-default-control-policy.ts

@@ -0,0 +1 @@
+export { applySpecifierDefaultControlPolicy } from '../apply-specifier-default-control-policy';

package/src/exports/default-namespace.ts

@@ -0,0 +1 @@
+export { soleDomainNamespaceId, UNBOUND_DOMAIN_NAMESPACE_ID } from '../default-namespace';

package/src/exports/resolve-domain-model.ts

@@ -0,0 +1 @@
+export { type ResolvedDomainModel, resolveDomainModel } from '../resolve-domain-model';

package/src/exports/types.ts

@@ -1,33 +1,39 @@
 export type {
   Contract,
   ContractExecutionSection,
-  ContractModelsMap,
-  ContractValueObjectsMap,
+  ContractModelDefinitions,
+  ContractValueObjectDefinitions,
 } from '../contract-types';
 export { DomainNamespaceResolutionError } from '../contract-validation-error';
+export type { ControlPolicy } from '../control-policy';
+export { effectiveControlPolicy } from '../control-policy';
 export type { CrossReference } from '../cross-reference';
 export { CrossReferenceSchema, crossRef } from '../cross-reference';
+export { soleDomainNamespaceId } from '../default-namespace';
 export type {
   ApplicationDomain,
   ApplicationDomainNamespace,
   ContractWithDomain,
 } from '../domain-envelope';
+export { UNBOUND_DOMAIN_NAMESPACE_ID } from '../domain-envelope';
 export {
-  contractModels,
-  contractValueObjects,
-  resolveSingleDomainNamespaceId,
-  UNBOUND_DOMAIN_NAMESPACE_ID,
-} from '../domain-envelope';
+  domainModelsAtDefaultNamespace,
+  domainValueObjectsAtDefaultNamespace,
+} from '../domain-namespace-access';
 export type {
   ContractDiscriminator,
   ContractEmbedRelation,
+  ContractEnum,
   ContractField,
   ContractFieldType,
+  ContractManyToManyRelation,
   ContractModel,
   ContractModelBase,
+  ContractNonJunctionRelation,
   ContractReferenceRelation,
   ContractRelation,
   ContractRelationOn,
+  ContractRelationThrough,
   ContractValueObject,
   ContractVariantEntry,
   EmbedRelationKeys,
@@ -39,6 +45,7 @@ export type {
 } from '../domain-types';
 export type { NamespaceId } from '../namespace-id';
 export { asNamespaceId } from '../namespace-id';
+export { type ResolvedDomainModel, resolveDomainModel } from '../resolve-domain-model';
 export type {
   $,
   Brand,
@@ -58,6 +65,7 @@ export type {
   GeneratedValueSpec,
   JsonPrimitive,
   JsonValue,
+  LedgerEntryRecord,
   PlanMeta,
   ProfileHashBase,
   Source,
@@ -74,3 +82,4 @@ export {
   isExecutionMutationDefaultValue,
   profileHash,
 } from '../types';
+export type { ValueSetRef } from '../value-set-ref';

package/src/hashing.ts

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { blindCast, castAs } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { JsonObject } from '@prisma-next/utils/json';
 import {
@@ -11,6 +12,33 @@ import type { ExecutionHashBase, ProfileHashBase, StorageHashBase } from './type
 
 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).
+function omitNamespaceKindsForHash(storage: unknown): unknown {
+  if (!isPlainRecord(storage)) {
+    return storage;
+  }
+  const namespaces = storage['namespaces'];
+  if (!isPlainRecord(namespaces)) {
+    return storage;
+  }
+  const stripped: Record<string, unknown> = {};
+  for (const [nsId, ns] of Object.entries(namespaces)) {
+    if (isPlainRecord(ns)) {
+      const { kind: _kind, ...rest } = ns;
+      stripped[nsId] = rest;
+    } else {
+      stripped[nsId] = ns;
+    }
+  }
+  return { ...storage, namespaces: stripped };
+}
+
 function sha256(content: string): string {
   const hash = createHash('sha256');
   hash.update(content);
@@ -24,28 +52,23 @@ type HashContractSection = Record<string, unknown> & {
 
 function hashContract(section: HashContractSection): string {
   const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;
-  // Blind cast: the synthesised object is a hash-only stand-in
-  // — never returned to callers, never executed as a Contract.
-  // `canonicalizeContract` only walks the storage / execution /
-  // capabilities slices, all of which are populated above, so the
-  // missing precise Contract typing on the other slots is
-  // immaterial for the hash result.
-  const contract = {
+  const storageForHash = omitNamespaceKindsForHash(sectionData['storage'] ?? {});
+  const contract = blindCast<Contract, 'hash-only partial contract for canonicalizeContract'>({
     targetFamily: sectionData['targetFamily'],
     target: sectionData['target'],
     roots: {},
     domain: { namespaces: {} },
-    storage: sectionData['storage'] ?? {},
     execution: sectionData['execution'],
     extensionPacks: {},
     capabilities: sectionData['capabilities'] ?? {},
     meta: {},
     profileHash: '',
     ...sectionData,
-  } as unknown as Contract;
+    storage: storageForHash,
+  });
   return canonicalizeContract(contract, {
     schemaVersion: SCHEMA_VERSION,
-    serializeContract: (c) => JSON.parse(JSON.stringify(c)) as JsonObject,
+    serializeContract: (c) => castAs<JsonObject>(JSON.parse(JSON.stringify(c))),
     ...ifDefined('shouldPreserveEmpty', shouldPreserveEmpty),
     ...ifDefined('sortStorage', sortStorage),
   });
@@ -60,7 +83,9 @@ export type ComputeStorageHashArgs = {
 };
 
 export function computeStorageHash(args: ComputeStorageHashArgs): StorageHashBase<string> {
-  return sha256(hashContract(args)) as StorageHashBase<string>;
+  return blindCast<StorageHashBase<string>, 'sha256 digest of canonicalized storage'>(
+    sha256(hashContract(args)),
+  );
 }
 
 export function computeExecutionHash(args: {
@@ -68,7 +93,9 @@ export function computeExecutionHash(args: {
   targetFamily: string;
   execution: Record<string, unknown>;
 }): ExecutionHashBase<string> {
-  return sha256(hashContract(args)) as ExecutionHashBase<string>;
+  return blindCast<ExecutionHashBase<string>, 'sha256 digest of canonicalized execution'>(
+    sha256(hashContract(args)),
+  );
 }
 
 export function computeProfileHash(args: {
@@ -76,5 +103,7 @@ export function computeProfileHash(args: {
   targetFamily: string;
   capabilities: Record<string, Record<string, boolean>>;
 }): ProfileHashBase<string> {
-  return sha256(hashContract(args)) as ProfileHashBase<string>;
+  return blindCast<ProfileHashBase<string>, 'sha256 digest of canonicalized profile'>(
+    sha256(hashContract(args)),
+  );
 }

package/src/resolve-domain-model.ts

@@ -0,0 +1,27 @@
+import type { ApplicationDomain } from './domain-envelope';
+import type { ContractModelBase } from './domain-types';
+
+export interface ResolvedDomainModel {
+  readonly namespaceId: string;
+  readonly model: ContractModelBase;
+}
+
+/**
+ * Resolve a bare domain model name to its namespace coordinate and model IR by
+ * scanning the contract's namespaces. For the single-namespace contracts in
+ * scope the scan is exact; cross-namespace bare-name collisions are selected
+ * explicitly (TML-2550).
+ */
+export function resolveDomainModel(
+  domain: ApplicationDomain,
+  modelName: string,
+): ResolvedDomainModel | undefined {
+  for (const namespaceId of Object.keys(domain.namespaces)) {
+    const model = domain.namespaces[namespaceId]?.models[modelName];
+    if (model !== undefined) {
+      return { namespaceId, model };
+    }
+  }
+
+  return undefined;
+}

package/src/types.ts

@@ -57,11 +57,13 @@ export type StorageEntitySlot = Readonly<Record<string, unknown>>;
 
 /**
  * Plain-data namespace entry in a storage block. Every hydrated contract
- * carries at least `id` plus zero or more entity-kind slot maps (`tables`,
- * `collections`, …). Foundation declares only this shape — no IR machinery.
+ * carries at least `id` plus entity-kind slot maps under `entries`
+ * (`table`, `collection`, …). Foundation declares only this shape — no IR
+ * machinery.
  */
 export interface StorageNamespace {
   readonly id: string;
+  readonly entries: Readonly<Record<string, StorageEntitySlot>>;
 }
 
 /**
@@ -243,3 +245,17 @@ export interface ContractMarkerRecord {
   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.
+ */
+export interface LedgerEntryRecord {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
+  readonly from: string | null;
+  readonly to: string;
+  readonly appliedAt: Date;
+  readonly operationCount: number;
+}

package/src/validate-domain.ts

@@ -140,6 +140,12 @@ function validateVariantsAndBases(modelIndex: ModelIndex, errors: string[]): voi
 function validateRelationTargets(modelIndex: ModelIndex, errors: string[]): void {
   for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
     for (const [relName, relation] of Object.entries(model.relations ?? {})) {
+      // Cross-space relations (relation.to.space is defined) target a model in a
+      // different contract space. The local domain index only contains this
+      // contract's own models, so the target is intentionally absent here.
+      // Existence of the target is verified by the aggregate verifier at
+      // deploy time (after the spaces are composed), not at parse time.
+      if (relation.to.space !== undefined) continue;
       if (!lookupModel(modelIndex, relation.to)) {
         errors.push(
           `Relation "${relName}" on model "${namespaceId}:${modelName}" targets "${relation.to.namespace}:${relation.to.model}" which does not exist in domain.namespaces`,

package/src/value-set-ref.ts

@@ -0,0 +1,26 @@
+/**
+ * Space-aware reference coordinate for a domain enum or storage value-set.
+ *
+ * `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.
+ *
+ * `entityKind` names the source entity-kind:
+ * - `'enum'` — the referenced entity is a domain enum.
+ * - `'value-set'` — the referenced entity is a storage value-set.
+ *
+ * `namespaceId` admits the `UNBOUND_NAMESPACE_ID` (`__unbound__`) sentinel for
+ * single-namespace (unbound) references.
+ *
+ * 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.
+ */
+export interface ValueSetRef {
+  readonly plane: 'domain' | 'storage';
+  readonly namespaceId: string;
+  readonly entityKind: 'enum' | 'value-set';
+  readonly name: string;
+  readonly spaceId?: string;
+}

package/dist/canonicalization-DFE0HJkI.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canonicalization-DFE0HJkI.d.mts","names":[],"sources":["../src/canonicalization.ts"],"mappings":";;;;;;AAcA;;;;;;KAAY,iBAAA,IAAqB,QAAA,EAAU,QAAA,KAAa,UAAU;;AAAA;AAUlE;;;;AAA6D;AAS7D;KATY,sBAAA,IAA0B,IAAuB;;;AASlB;AA6K3C;;;;KA7KY,WAAA,IAAe,OAAgB;AAAA,UA6K1B,2BAAA;EAAA,SACN,aAAA;EAAA;;;;;;;;AA0ByB;AAQpC;EAlCW,SAWA,iBAAA,EAAmB,iBAAA;;;;;;;WAOnB,mBAAA,GAAsB,sBAAA;EAiB/B;;;;;AAEO;AA0BT;EA5BE,SATS,WAAA,GAAc,WAAA;AAAA;;;;;;iBAQT,4BAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAAA,GACR,MAAA;AAAA,iBA0Ba,oBAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,2BAA2B"}

package/dist/contract-types-xgwKtd7y.d.mts.map

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

package/dist/domain-envelope-4hyFtJ4_.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"domain-envelope-4hyFtJ4_.d.mts","names":[],"sources":["../src/namespace-id.ts","../src/cross-reference.ts","../src/domain-types.ts","../src/domain-envelope.ts"],"mappings":"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"}