@prisma-next/family-sql 0.14.0-dev.3 → 0.14.0-dev.31

package/src/core/ir/sql-contract-serializer-base.ts

@@ -6,18 +6,15 @@ import {
   type AnyEntityKindDescriptor,
   hydrateNamespaceEntities,
   type Namespace,
-  NamespaceBase,
-  UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import { sqlContractCanonicalizationHooks } from '@prisma-next/sql-contract/canonicalization-hooks';
 import { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';
 import {
-  buildSqlNamespace,
-  type SqlNamespaceTablesInput,
+  isMaterializedSqlNamespace,
+  type SqlNamespaceInput,
   SqlStorage,
   type SqlStorageInput,
   type SqlStorageTypeEntry,
-  SqlUnboundNamespace,
 } from '@prisma-next/sql-contract/types';
 import {
   createSqlContractSchema,
@@ -120,77 +117,48 @@ export abstract class SqlContractSerializerBase<TContract extends Contract<SqlSt
         'structural',
       );
     }
-    const hydratedNamespaces = this.hydrateSqlNamespaceMap(rawNamespaces);
-    // Compatibility shim: production code that addresses `__unbound__` for table
-    // metadata lookups (collection-contract, query-plan-mutations, model-accessor,
-    // query-plan-meta, where-binding) uses optional chaining and tolerates absence,
-    // but runtime-qualification (TML-2605) has not yet landed cross-namespace table
-    // routing. Injecting the empty singleton here keeps helpers that augment the
-    // deserialized JSON (e.g. buildMixedPolyContract) working by providing a slot to
-    // write into. Once runtime-qualification routes table lookups by namespace, this
-    // shim should be removed.
-    //
-    // TML-2916: the shim only fires when the target's default namespace IS unbound
-    // (SQLite, Mongo). On Postgres (`defaultNamespaceId === 'public'`) injecting an
-    // empty `__unbound__` slot violates ADR 223 — un-namespaced PG models belong in
-    // `public`, not `__unbound__`.
-    const withInjectedUnbound =
-      this.defaultNamespaceId === UNBOUND_NAMESPACE_ID
-        ? {
-            ...hydratedNamespaces,
-            [UNBOUND_NAMESPACE_ID]:
-              hydratedNamespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance,
-          }
-        : hydratedNamespaces;
+    const hydratedNamespaces = this.hydrateSqlNamespaceMap(
+      blindCast<
+        Readonly<Record<string, Record<string, unknown>>>,
+        'parseSqlContractStructure validated raw JSON; namespace entries are plain objects, not SqlNamespace instances.'
+      >(rawNamespaces),
+    );
 
     return {
       ...validated,
       storage: new SqlStorage({
         storageHash: validated.storage.storageHash,
         ...ifDefined('types', hydratedTypes),
-        // Cast narrows the result of hydrateSqlNamespaceMap from the wider
-        // framework `Namespace` to the SQL-family `SqlNamespace`.
         namespaces: blindCast<
           SqlStorageInput['namespaces'],
-          'hydrateSqlNamespaceMap builds each namespace through the SQL family concretions (SqlBoundNamespace / target schema), so every value is a SqlNamespace; the framework return type only promises the base Namespace.'
-        >(withInjectedUnbound),
+          'hydrateSqlNamespaceMap builds each namespace through the target serializer override, so every value is a SqlNamespace; the framework return type only promises the base Namespace.'
+        >(hydratedNamespaces),
       }),
     };
   }
 
-  protected abstract get defaultNamespaceId(): string;
-
   protected hydrateSqlNamespaceMap(
-    namespaces: Readonly<Record<string, Namespace | Record<string, unknown>>>,
+    namespaces: Readonly<Record<string, Record<string, unknown>>>,
   ): Readonly<Record<string, Namespace>> {
     return Object.fromEntries(
       Object.entries(namespaces).map(([nsId, namespaceEntryRaw]) => {
-        // Raw entries passed structural validation; hydrate materialises family IR class instances.
         const namespaceHydrated = this.hydrateSqlNamespaceEntry(nsId, namespaceEntryRaw);
-        const namespaceMaterialised =
-          namespaceHydrated instanceof NamespaceBase
-            ? namespaceHydrated
-            : buildSqlNamespace(
-                blindCast<
-                  SqlNamespaceTablesInput,
-                  'hydrateSqlNamespaceEntry returns SqlNamespaceTablesInput when raw is not a NamespaceBase'
-                >(namespaceHydrated),
-              );
-        return [nsId, namespaceMaterialised];
+        if (!isMaterializedSqlNamespace(namespaceHydrated)) {
+          throw new Error(
+            `Target serializer bug: hydrateSqlNamespaceEntry for namespace "${nsId}" returned a non-NamespaceBase value. Override hydrateSqlNamespaceEntry to produce a target namespace concretion.`,
+          );
+        }
+        return [nsId, namespaceHydrated];
       }),
     );
   }
 
   protected hydrateSqlNamespaceEntry(
     nsId: string,
-    raw: Namespace | Record<string, unknown>,
-  ): Namespace | SqlNamespaceTablesInput {
-    if (raw instanceof NamespaceBase) {
-      return raw;
-    }
-    const rawRecord = isPlainRecord(raw) ? raw : {};
-    const id = typeof rawRecord['id'] === 'string' ? rawRecord['id'] : nsId;
-    const parsed = NamespaceRawSchema({ ...rawRecord, id });
+    raw: Record<string, unknown>,
+  ): Namespace | SqlNamespaceInput {
+    const id = typeof raw['id'] === 'string' ? raw['id'] : nsId;
+    const parsed = NamespaceRawSchema({ ...raw, id });
     if (parsed instanceof type.errors) {
       const messages = parsed.map((p: { message: string }) => p.message).join('; ');
       throw new ContractValidationError(`Namespace hydration failed: ${messages}`, 'structural');
@@ -211,8 +179,8 @@ export abstract class SqlContractSerializerBase<TContract extends Contract<SqlSt
     }
 
     return blindCast<
-      SqlNamespaceTablesInput,
-      'entriesOutput holds the hydrated SQL entity-kind maps (table always present); this wraps them as the SqlNamespaceTablesInput the family createNamespace consumes.'
+      SqlNamespaceInput,
+      'entriesOutput holds the hydrated SQL entity-kind maps (table always present); this wraps them as the SqlNamespaceInput the target createNamespace consumes.'
     >({
       id,
       entries: entriesOutput,

package/src/core/ir/sql-contract-serializer.ts

@@ -1,5 +1,4 @@
 import type { Contract } from '@prisma-next/contract/types';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import { SqlContractSerializerBase } from './sql-contract-serializer-base';
 
@@ -11,15 +10,14 @@ import { SqlContractSerializerBase } from './sql-contract-serializer-base';
  * codec-typed envelope wire a target-specific subclass with a populated
  * registry (see Postgres). Family-level call sites instantiate this
  * default directly when no target serializer is supplied.
+ *
+ * Because this serializer has no target concretion, deserialization of
+ * contracts that include namespace entries from JSON will throw unless
+ * the caller provides pre-hydrated `NamespaceBase` instances. Production
+ * paths always supply a target-specific serializer.
  */
 export class SqlContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor() {
     super(new Map());
   }
-
-  // Family-level fallback when no target descriptor is wired in. Preserves the
-  // pre-TML-2916 compatibility-shim behaviour for the unbound slot.
-  protected override get defaultNamespaceId(): string {
-    return UNBOUND_NAMESPACE_ID;
-  }
 }

package/src/core/migrations/contract-to-schema-ir.ts

@@ -4,10 +4,11 @@ import {
   type CheckConstraint,
   type ForeignKey,
   type Index,
+  isStorageTable,
   isStorageTypeInstance,
   type SqlStorage,
   type StorageColumn,
-  StorageTable,
+  type StorageTable,
   type StorageTypeInstance,
   type UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
@@ -82,13 +83,14 @@ function convertColumn(
   // typeRef and produces `"vector(1536)"` — making diffs on the same
   // contract falsely report a `type_mismatch`.
   const resolved = resolveColumnTypeMetadata(column, storageTypes);
-  const nativeType = expandNativeType
+  const baseNativeType = expandNativeType
     ? expandNativeType({
         nativeType: resolved.nativeType,
         codecId: resolved.codecId,
         ...ifDefined('typeParams', resolved.typeParams),
       })
     : resolved.nativeType;
+  const nativeType = column.many ? `${baseNativeType}[]` : baseNativeType;
   return {
     name,
     nativeType,
@@ -303,7 +305,7 @@ export function detectDestructiveChanges(
 
     for (const tableName of Object.keys(fromTables)) {
       const toTableRaw = toNs?.entries.table?.[tableName];
-      if (!(toTableRaw instanceof StorageTable)) {
+      if (!isStorageTable(toTableRaw)) {
         conflicts.push({
           kind: 'tableRemoved',
           summary: `Table "${tableName}" was removed`,
@@ -313,7 +315,7 @@ export function detectDestructiveChanges(
       const toTable = toTableRaw;
 
       const fromTableRaw = fromTables[tableName];
-      if (!(fromTableRaw instanceof StorageTable)) continue;
+      if (!isStorageTable(fromTableRaw)) continue;
       const fromTable = fromTableRaw;
 
       for (const columnName of Object.keys(fromTable.columns)) {
@@ -377,7 +379,7 @@ export function contractToSchemaIR(
   const tables: Record<string, SqlTableIR> = {};
   for (const ns of Object.values(storage.namespaces)) {
     for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
-      if (!(tableDefRaw instanceof StorageTable)) {
+      if (!isStorageTable(tableDefRaw)) {
         throw new Error(
           `contractToSchemaIR: expected StorageTable at namespaces.${ns.id}.entries.table.${tableName}`,
         );

package/src/core/migrations/field-event-planner.ts

@@ -24,7 +24,12 @@
 
 import type { Contract } from '@prisma-next/contract/types';
 import type { OpFactoryCall } from '@prisma-next/framework-components/control';
-import { type SqlStorage, type StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
+import {
+  isStorageTable,
+  type SqlStorage,
+  type StorageColumn,
+  type StorageTable,
+} from '@prisma-next/sql-contract/types';
 import type { CodecControlHooks, FieldEvent, FieldEventContext } from './types';
 
 export interface PlanFieldEventOperationsOptions {
@@ -88,8 +93,8 @@ export function planFieldEventOperations(
     for (const tableName of tableNames) {
       const priorTableRaw = priorTables?.[tableName];
       const newTableRaw = newTables?.[tableName];
-      const priorTable = priorTableRaw instanceof StorageTable ? priorTableRaw : undefined;
-      const newTable = newTableRaw instanceof StorageTable ? newTableRaw : undefined;
+      const priorTable = isStorageTable(priorTableRaw) ? priorTableRaw : undefined;
+      const newTable = isStorageTable(newTableRaw) ? newTableRaw : undefined;
       const fieldNames = unionSorted(
         priorTable ? Object.keys(priorTable.columns) : [],
         newTable ? Object.keys(newTable.columns) : [],

package/src/core/psl-contract-infer/sql-schema-ir-to-psl-ast.ts

@@ -305,7 +305,7 @@ function buildScalarField(
       name: fieldName,
       typeName: `Unsupported("${escapePslString(resolution.nativeType)}")`,
       optional: column.nullable,
-      list: false,
+      list: column.many === true,
       attributes: attrs,
       span: SYNTHETIC_SPAN,
     };
@@ -354,7 +354,7 @@ function buildScalarField(
     name: fieldName,
     typeName,
     optional: column.nullable,
-    list: false,
+    list: column.many === true,
     attributes,
     span: SYNTHETIC_SPAN,
   };

package/src/core/schema-verify/verify-sql-schema.ts

@@ -18,10 +18,11 @@ import type {
 } from '@prisma-next/framework-components/control';
 
 import {
+  isStorageTable,
   isStorageTypeInstance,
   type SqlStorage,
   type StorageColumn,
-  StorageTable,
+  type StorageTable,
   type StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
@@ -236,6 +237,7 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
     },
     schema: {
       issues,
+      schemaDiffIssues: [],
       root,
       counts,
     },
@@ -297,7 +299,7 @@ function verifySchemaTables(options: {
     const ns = contract.storage.namespaces[namespaceId];
     if (!ns) continue;
     for (const [tableName, contractTableRaw] of Object.entries(ns.entries.table ?? {})) {
-      if (!(contractTableRaw instanceof StorageTable)) {
+      if (!isStorageTable(contractTableRaw)) {
         throw new Error(
           `verifySqlSchema: expected StorageTable at storage.namespaces.${namespaceId}.entries.table.${tableName}`,
         );
@@ -790,8 +792,9 @@ function verifyColumn(options: {
     tableName,
     columnName,
   });
-  const schemaNativeType =
+  const schemaBaseNativeType =
     normalizeNativeType?.(schemaColumn.nativeType) ?? schemaColumn.nativeType;
+  const schemaNativeType = schemaColumn.many ? `${schemaBaseNativeType}[]` : schemaBaseNativeType;
 
   const typesMatch = contractNativeType === schemaNativeType;
 
@@ -1144,19 +1147,20 @@ function renderExpectedNativeType(
     context,
   );
 
+  let baseType: string;
+
   // If no typeParams or codecId, return the base native type
   if (!typeParams || !codecId) {
-    return nativeType;
-  }
-
-  // Try to use the codec's expandNativeType hook if available
-  const hooks = codecHooks.get(codecId);
-  if (hooks?.expandNativeType) {
-    return hooks.expandNativeType({ nativeType, codecId, typeParams });
+    baseType = nativeType;
+  } else {
+    // Try to use the codec's expandNativeType hook if available
+    const hooks = codecHooks.get(codecId);
+    baseType = hooks?.expandNativeType
+      ? hooks.expandNativeType({ nativeType, codecId, typeParams })
+      : nativeType;
   }
 
-  // Fallback: return base native type if no hook is available
-  return nativeType;
+  return contractColumn.many ? `${baseType}[]` : baseType;
 }
 
 function resolveContractColumnTypeMetadata(

package/dist/sql-contract-serializer-BR2vC7Z-.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql-contract-serializer-BR2vC7Z-.mjs","names":[],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts"],"sourcesContent":["import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport { isPlainRecord } from '@prisma-next/contract/is-plain-record';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { ContractSerializer } from '@prisma-next/framework-components/control';\nimport {\n  type AnyEntityKindDescriptor,\n  hydrateNamespaceEntities,\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { sqlContractCanonicalizationHooks } from '@prisma-next/sql-contract/canonicalization-hooks';\nimport { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';\nimport {\n  buildSqlNamespace,\n  type SqlNamespaceTablesInput,\n  SqlStorage,\n  type SqlStorageInput,\n  type SqlStorageTypeEntry,\n  SqlUnboundNamespace,\n} from '@prisma-next/sql-contract/types';\nimport {\n  createSqlContractSchema,\n  validateSqlContractFully,\n} from '@prisma-next/sql-contract/validators';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { type Type, type } from 'arktype';\n\nconst NamespaceRawSchema = type({\n  id: 'string',\n  'kind?': 'string',\n  entries: type({\n    '+': 'ignore',\n  }),\n});\n\nexport type SqlEntityHydrationFactory = (entry: unknown) => unknown;\n\n/**\n * SQL family `ContractSerializer` abstract base. Carries the SQL-shared\n * deserialization pipeline:\n *\n * 1. `parseSqlContractStructure` validates the on-disk JSON envelope\n *    against the SQL contract arktype schema (`validateSqlContractFully`)\n *    and returns the validated flat-data shape.\n * 2. `hydrateSqlStorage` walks the validated `storage` subtree and\n *    constructs the family-shared SQL Contract IR class hierarchy\n *    (`SqlStorage` -> `StorageTable` -> `StorageColumn` / `PrimaryKey`\n *    / …). The rest of the contract envelope is JSON-clean primitive\n *    data and passes through unchanged.\n * 3. `constructTargetContract` is the target-specific extension hook;\n *    defaults to identity. Targets that need to attach target-only\n *    fields (e.g. target-specific derived storage fields) override it.\n *\n * Default `serializeContract` is identity over the contract — concrete\n * SQL targets ship JSON-clean class instances, so the contract value\n * can be stringified directly. The non-enumerable family-level `kind`\n * discriminator on `SqlNode` instances stays out of the persisted\n * envelope automatically. Targets that need to canonicalize on the way\n * out (key ordering, dropping computed-only fields) override\n * `serializeContract` directly.\n */\nexport abstract class SqlContractSerializerBase<TContract extends Contract<SqlStorage>>\n  implements ContractSerializer<TContract>\n{\n  private readonly contractSchema: Type<unknown> | undefined;\n  private readonly entryKinds: ReadonlyMap<string, AnyEntityKindDescriptor>;\n\n  constructor(\n    protected readonly entityHydrationRegistry: ReadonlyMap<\n      string,\n      SqlEntityHydrationFactory\n    > = new Map(),\n    packEntityKinds: readonly AnyEntityKindDescriptor[] = [],\n  ) {\n    this.entryKinds = composeSqlEntityKinds(packEntityKinds);\n    this.contractSchema =\n      packEntityKinds.length > 0 ? createSqlContractSchema(this.entryKinds) : undefined;\n  }\n\n  deserializeContract<T extends TContract = TContract>(json: unknown): T {\n    const validated = this.parseSqlContractStructure(json);\n    const hydrated = this.hydrateSqlStorage(validated);\n    return this.constructTargetContract(hydrated) as T;\n  }\n\n  serializeContract(contract: TContract): JsonObject {\n    return contract as unknown as JsonObject;\n  }\n\n  shouldPreserveEmpty = sqlContractCanonicalizationHooks.shouldPreserveEmpty;\n\n  sortStorage = sqlContractCanonicalizationHooks.sortStorage;\n\n  protected parseSqlContractStructure(json: unknown): Contract<SqlStorage> {\n    return validateSqlContractFully<Contract<SqlStorage>>(\n      json,\n      this.contractSchema !== undefined ? { contractSchema: this.contractSchema } : undefined,\n    );\n  }\n\n  protected hydrateSqlStorage(validated: Contract<SqlStorage>): Contract<SqlStorage> {\n    const types = validated.storage.types;\n    const hydratedTypes =\n      types !== undefined\n        ? Object.fromEntries(\n            Object.entries(types).map(([name, entry]) => [\n              name,\n              this.hydrateStorageTypeEntry(entry),\n            ]),\n          )\n        : undefined;\n\n    const rawNamespaces = validated.storage.namespaces;\n    if (rawNamespaces === undefined) {\n      throw new ContractValidationError(\n        'Contract storage.namespaces is required after structural validation',\n        'structural',\n      );\n    }\n    const hydratedNamespaces = this.hydrateSqlNamespaceMap(rawNamespaces);\n    // Compatibility shim: production code that addresses `__unbound__` for table\n    // metadata lookups (collection-contract, query-plan-mutations, model-accessor,\n    // query-plan-meta, where-binding) uses optional chaining and tolerates absence,\n    // but runtime-qualification (TML-2605) has not yet landed cross-namespace table\n    // routing. Injecting the empty singleton here keeps helpers that augment the\n    // deserialized JSON (e.g. buildMixedPolyContract) working by providing a slot to\n    // write into. Once runtime-qualification routes table lookups by namespace, this\n    // shim should be removed.\n    //\n    // TML-2916: the shim only fires when the target's default namespace IS unbound\n    // (SQLite, Mongo). On Postgres (`defaultNamespaceId === 'public'`) injecting an\n    // empty `__unbound__` slot violates ADR 223 — un-namespaced PG models belong in\n    // `public`, not `__unbound__`.\n    const withInjectedUnbound =\n      this.defaultNamespaceId === UNBOUND_NAMESPACE_ID\n        ? {\n            ...hydratedNamespaces,\n            [UNBOUND_NAMESPACE_ID]:\n              hydratedNamespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance,\n          }\n        : hydratedNamespaces;\n\n    return {\n      ...validated,\n      storage: new SqlStorage({\n        storageHash: validated.storage.storageHash,\n        ...ifDefined('types', hydratedTypes),\n        // Cast narrows the result of hydrateSqlNamespaceMap from the wider\n        // framework `Namespace` to the SQL-family `SqlNamespace`.\n        namespaces: blindCast<\n          SqlStorageInput['namespaces'],\n          'hydrateSqlNamespaceMap builds each namespace through the SQL family concretions (SqlBoundNamespace / target schema), so every value is a SqlNamespace; the framework return type only promises the base Namespace.'\n        >(withInjectedUnbound),\n      }),\n    };\n  }\n\n  protected abstract get defaultNamespaceId(): string;\n\n  protected hydrateSqlNamespaceMap(\n    namespaces: Readonly<Record<string, Namespace | Record<string, unknown>>>,\n  ): Readonly<Record<string, Namespace>> {\n    return Object.fromEntries(\n      Object.entries(namespaces).map(([nsId, namespaceEntryRaw]) => {\n        // Raw entries passed structural validation; hydrate materialises family IR class instances.\n        const namespaceHydrated = this.hydrateSqlNamespaceEntry(nsId, namespaceEntryRaw);\n        const namespaceMaterialised =\n          namespaceHydrated instanceof NamespaceBase\n            ? namespaceHydrated\n            : buildSqlNamespace(\n                blindCast<\n                  SqlNamespaceTablesInput,\n                  'hydrateSqlNamespaceEntry returns SqlNamespaceTablesInput when raw is not a NamespaceBase'\n                >(namespaceHydrated),\n              );\n        return [nsId, namespaceMaterialised];\n      }),\n    );\n  }\n\n  protected hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const rawRecord = isPlainRecord(raw) ? raw : {};\n    const id = typeof rawRecord['id'] === 'string' ? rawRecord['id'] : nsId;\n    const parsed = NamespaceRawSchema({ ...rawRecord, id });\n    if (parsed instanceof type.errors) {\n      const messages = parsed.map((p: { message: string }) => p.message).join('; ');\n      throw new ContractValidationError(`Namespace hydration failed: ${messages}`, 'structural');\n    }\n    const entriesRaw = parsed.entries;\n    const rawEntriesMap = isPlainRecord(entriesRaw) ? entriesRaw : {};\n\n    const entriesInput: Record<string, Readonly<Record<string, unknown>>> = {};\n    for (const [key, innerMap] of Object.entries(rawEntriesMap)) {\n      entriesInput[key] = isPlainRecord(innerMap) ? innerMap : Object.freeze({});\n    }\n\n    const entriesOutput = hydrateNamespaceEntities(entriesInput, this.entryKinds, 'fail', id);\n\n    // Always ensure a 'table' key is present (may be empty).\n    if (!Object.hasOwn(entriesOutput, 'table')) {\n      entriesOutput['table'] = {};\n    }\n\n    return blindCast<\n      SqlNamespaceTablesInput,\n      'entriesOutput holds the hydrated SQL entity-kind maps (table always present); this wraps them as the SqlNamespaceTablesInput the family createNamespace consumes.'\n    >({\n      id,\n      entries: entriesOutput,\n    });\n  }\n\n  protected hydrateStorageTypeEntry(entry: SqlStorageTypeEntry): SqlStorageTypeEntry {\n    if (typeof entry !== 'object' || entry === null) {\n      return entry;\n    }\n    const kind = (entry as { kind?: unknown }).kind;\n    if (typeof kind !== 'string') {\n      return entry;\n    }\n    const factory = this.entityHydrationRegistry.get(kind);\n    if (factory === undefined) {\n      return entry;\n    }\n    return blindCast<\n      SqlStorageTypeEntry,\n      'entity registry factory returns SqlStorageTypeEntry for storage.types entries'\n    >(factory(entry));\n  }\n\n  protected constructTargetContract(hydrated: Contract<SqlStorage>): TContract {\n    return hydrated as TContract;\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { SqlContractSerializerBase } from './sql-contract-serializer-base';\n\n/**\n * Default SQL family `ContractSerializer` concretion. Inherits the\n * full SQL-shared deserialization pipeline (structural validation +\n * IR-class hydration) without pack-registered `storage.types`\n * hydration factories — targets that emit polymorphic JSON outside the\n * codec-typed envelope wire a target-specific subclass with a populated\n * registry (see Postgres). Family-level call sites instantiate this\n * default directly when no target serializer is supplied.\n */\nexport class SqlContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    super(new Map());\n  }\n\n  // Family-level fallback when no target descriptor is wired in. Preserves the\n  // pre-TML-2916 compatibility-shim behaviour for the unbound slot.\n  protected override get defaultNamespaceId(): string {\n    return UNBOUND_NAMESPACE_ID;\n  }\n}\n"],"mappings":"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"}

package/dist/test-utils.d.mts

@@ -1,2 +0,0 @@
-import { extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports } from "@prisma-next/framework-components/control";
-export { extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports };

package/dist/test-utils.mjs

@@ -1,2 +0,0 @@
-import { extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports } from "@prisma-next/framework-components/control";
-export { extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports };