@prisma-next/target-postgres 0.13.0-dev.25 → 0.13.0-dev.27

package/dist/types.d.mts

@@ -1,16 +1,30 @@
 import { n as PostgresEnumTypeInput, t as PostgresEnumType } from "./postgres-enum-type-BVn63a89.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
 import { NamespaceBase } from "@prisma-next/framework-components/ir";
-import { PostgresEnumStorageEntry, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageTableInput, StorageValueSet, StorageValueSetInput } from "@prisma-next/sql-contract/types";
+import { PostgresEnumStorageEntry, SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
 
+//#region src/core/postgres-enum-type-schema.d.ts
+/**
+ * Arktype validator for a `postgres-enum` entry under
+ * `storage.namespaces[id].entries.type[name]`. Registered by the Postgres
+ * target pack against the `'type'` entries key so the family-layer namespace
+ * validator accepts (and rejects) entries of this kind.
+ */
+declare const PostgresEnumTypeSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  kind: "postgres-enum";
+  values: readonly string[];
+  name?: string;
+  nativeType?: string;
+  control?: "managed" | "tolerated" | "external" | "observed";
+}, {}>;
+//#endregion
 //#region src/core/postgres-schema.d.ts
+type PostgresNamespaceEntries = SqlNamespaceEntries & {
+  readonly type?: Readonly<Record<string, PostgresEnumType>>;
+};
 interface PostgresSchemaInput {
   readonly id: string;
-  readonly entries: {
-    readonly table: Record<string, StorageTable | StorageTableInput>;
-    readonly type: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
-    readonly valueSet?: Record<string, StorageValueSet | StorageValueSetInput>;
-  };
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 /**
  * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
@@ -18,7 +32,7 @@ interface PostgresSchemaInput {
  * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
  * the Postgres PSL interpreter from `namespace { … }` AST buckets.
  *
- * `entries` holds entity-kind slot maps (`table`, `type`). Qualifier
+ * `entries` holds entity-kind maps (`table`, `type`). Qualifier
  * emission is the rendering seam: DDL / SQL emission asks the namespace
  * for its qualifier (`"<schema>"`) or for a qualified table name
  * (`"<schema>"."<table>"`) and consumes the result polymorphically.
@@ -37,12 +51,11 @@ declare class PostgresSchema extends NamespaceBase {
   static unbound: PostgresUnboundSchema;
   readonly kind: 'schema';
   readonly id: string;
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-    readonly type: Readonly<Record<string, PostgresEnumType>>;
-    readonly valueSet?: Readonly<Record<string, StorageValueSet>>;
-  }>;
+  readonly entries: PostgresNamespaceEntries;
   constructor(input: PostgresSchemaInput);
+  get table(): Readonly<Record<string, StorageTable>>;
+  get type(): Readonly<Record<string, PostgresEnumType>>;
+  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
   /**
    * The bare schema qualifier as it would appear in a rendered SQL
    * fragment (already quoted). The unbound-schema singleton overrides
@@ -124,5 +137,5 @@ declare class PostgresUnboundSchema extends PostgresSchema {
  */
 declare function postgresCreateNamespace(input: SqlNamespaceTablesInput, enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>): PostgresSchema;
 //#endregion
-export { type PostgresColumnDefault, PostgresEnumType, type PostgresEnumTypeInput, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
+export { type PostgresColumnDefault, PostgresEnumType, type PostgresEnumTypeInput, PostgresEnumTypeSchema, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;;UAiBiB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA;IAAA,SACE,KAAA,EAAO,MAAA,SAAe,YAAA,GAAe,iBAAA;IAAA,SACrC,IAAA,EAAM,MAAA,SAAe,gBAAA,GAAmB,qBAAA;IAAA,SACxC,QAAA,GAAW,MAAA,SAAe,eAAA,GAAkB,oBAAA;EAAA;AAAA;;;;;;;;;;;;;;;cAkB5C,cAAA,SAAuB,aAAA;EAnBvB;;;;;;;EAAA,OA2BJ,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,QAAA;IAAA,SACP,KAAA,EAAO,QAAA,CAAS,MAAA,SAAe,YAAA;IAAA,SAC/B,IAAA,EAAM,QAAA,CAAS,MAAA,SAAe,gBAAA;IAAA,SAC9B,QAAA,GAAW,QAAA,CAAS,MAAA,SAAe,eAAA;EAAA;cAGlC,KAAA,EAAO,mBAAA;EALD;;;;;EAsDlB,SAAA;EApDsB;;;;;;EA8DtB,YAAA,CAAa,SAAA;EA7EqB;;;;;;EAuFlC,eAAA,CAAgB,IAAA;EA1EL;;;;;;;;EAsFX,mBAAA;EApFsB;;;;;;;;;;;EAmGtB,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;AAAU;AAwBpC;;;;;;;;;;;;;;;cAAa,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;AAAA;;;;;;;AAkCM;;;;;iBAHD,uBAAA,CACd,KAAA,EAAO,uBAAA,EACP,SAAA,GAAY,QAAA,CAAS,MAAA,SAAe,wBAAA,KACnC,cAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/core/postgres-enum-type-schema.ts","../src/core/postgres-schema.ts"],"mappings":";;;;;;;;;;;;cAUa,sBAAA,gDAAsB,UAAA;;;;;;;;;KCUvB,wBAAA,GAA2B,mBAAA;EAAA,SAC5B,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,gBAAA;AAAA;AAAA,UAGzB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;AANrD;;;cAuBa,cAAA,SAAuB,aAAA;EAtBM;;;;;;;EAAA,OA8BjC,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,wBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IAgEf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,IAAA,IAAQ,QAAA,CAAS,MAAA,SAAe,gBAAA;EAAA,IAIhC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EAvGW;;;;;EAgHnD,SAAA;EAjHS;;;;;;EA2HT,YAAA,CAAa,SAAA;EA1H4C;AAiB3D;;;;;EAmHE,eAAA,CAAgB,IAAA;EArCqB;;;;;;;;EAiDrC,mBAAA;EAewB;;;;;;;;;;;EAAxB,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;cAwBb,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;AAAA;;;;;;;;AAAmB;AA+B9B;;;iBAAgB,uBAAA,CACd,KAAA,EAAO,uBAAA,EACP,SAAA,GAAY,QAAA,CAAS,MAAA,SAAe,wBAAA,KACnC,cAAA"}

package/dist/types.mjs

@@ -1,3 +1,4 @@
 import { t as PostgresEnumType } from "./postgres-enum-type-DPKqCBem.mjs";
-import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-BAgkIU9u.mjs";
-export { PostgresEnumType, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
+import { t as PostgresEnumTypeSchema } from "./postgres-enum-type-schema-DZBTtvBF.mjs";
+import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-C7c9rhGk.mjs";
+export { PostgresEnumType, PostgresEnumTypeSchema, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.13.0-dev.25",
+  "version": "0.13.0-dev.27",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.13.0-dev.25",
-    "@prisma-next/contract": "0.13.0-dev.25",
-    "@prisma-next/errors": "0.13.0-dev.25",
-    "@prisma-next/family-sql": "0.13.0-dev.25",
-    "@prisma-next/framework-components": "0.13.0-dev.25",
-    "@prisma-next/migration-tools": "0.13.0-dev.25",
-    "@prisma-next/ts-render": "0.13.0-dev.25",
-    "@prisma-next/sql-contract": "0.13.0-dev.25",
-    "@prisma-next/sql-errors": "0.13.0-dev.25",
-    "@prisma-next/sql-operations": "0.13.0-dev.25",
-    "@prisma-next/sql-relational-core": "0.13.0-dev.25",
-    "@prisma-next/sql-schema-ir": "0.13.0-dev.25",
-    "@prisma-next/utils": "0.13.0-dev.25",
+    "@prisma-next/cli": "0.13.0-dev.27",
+    "@prisma-next/contract": "0.13.0-dev.27",
+    "@prisma-next/errors": "0.13.0-dev.27",
+    "@prisma-next/family-sql": "0.13.0-dev.27",
+    "@prisma-next/framework-components": "0.13.0-dev.27",
+    "@prisma-next/migration-tools": "0.13.0-dev.27",
+    "@prisma-next/ts-render": "0.13.0-dev.27",
+    "@prisma-next/sql-contract": "0.13.0-dev.27",
+    "@prisma-next/sql-errors": "0.13.0-dev.27",
+    "@prisma-next/sql-operations": "0.13.0-dev.27",
+    "@prisma-next/sql-relational-core": "0.13.0-dev.27",
+    "@prisma-next/sql-schema-ir": "0.13.0-dev.27",
+    "@prisma-next/utils": "0.13.0-dev.27",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0-dev.25",
-    "@prisma-next/tsconfig": "0.13.0-dev.25",
-    "@prisma-next/tsdown": "0.13.0-dev.25",
+    "@prisma-next/test-utils": "0.13.0-dev.27",
+    "@prisma-next/tsconfig": "0.13.0-dev.27",
+    "@prisma-next/tsdown": "0.13.0-dev.27",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/core/authoring.ts

@@ -5,8 +5,8 @@ import type {
   AuthoringTypeNamespace,
 } from '@prisma-next/framework-components/authoring';
 import type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';
-import { PostgresEnumTypeSchema } from '@prisma-next/sql-contract/validators';
 import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
+import { PostgresEnumTypeSchema } from './postgres-enum-type-schema';
 
 export const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;
 

package/src/core/migrations/control-policy.ts

@@ -1,11 +1,11 @@
 import type { Contract } from '@prisma-next/contract/types';
 import type { ControlPolicySubject } from '@prisma-next/family-sql/control';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import { entityAt, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   isPostgresEnumStorageEntry,
   type SqlStorage,
-  storageTableAt,
+  type StorageTable,
 } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { isPostgresSchema } from '../postgres-schema';
@@ -43,7 +43,11 @@ function resolveNamespaceIdForTable(
   ddlSchemaName: string | undefined,
 ): string {
   for (const namespaceId of Object.keys(contract.storage.namespaces)) {
-    const table = storageTableAt(contract.storage, namespaceId, tableName);
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
     if (!table) continue;
     if (
       ddlSchemaName === undefined ||
@@ -122,7 +126,7 @@ export function resolvePostgresCallControlPolicySubject(
       ? resolveNamespaceIdForDdlSchema(contract, callFields.schemaName)
       : UNBOUND_NAMESPACE_ID;
     const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[callFields.typeName] : undefined;
+    const rawEnum = isPostgresSchema(ns) ? ns.type[callFields.typeName] : undefined;
     const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
     return {
       namespaceId,
@@ -138,7 +142,11 @@ export function resolvePostgresCallControlPolicySubject(
       callFields.tableName,
       callFields.schemaName,
     );
-    const table = storageTableAt(contract.storage, namespaceId, callFields.tableName);
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: callFields.tableName,
+    });
     const tableControlPolicy = table?.control;
     return {
       namespaceId,
@@ -205,7 +213,7 @@ export function resolvePostgresIssueControlPolicySubject(
     const namespaceId =
       'namespaceId' in issue && issue.namespaceId ? issue.namespaceId : UNBOUND_NAMESPACE_ID;
     const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[issue.typeName] : undefined;
+    const rawEnum = isPostgresSchema(ns) ? ns.type[issue.typeName] : undefined;
     const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
     return {
       namespaceId,
@@ -220,7 +228,11 @@ export function resolvePostgresIssueControlPolicySubject(
       'namespaceId' in issue && issue.namespaceId
         ? issue.namespaceId
         : resolveNamespaceIdForTable(contract, issue.table, undefined);
-    const table = storageTableAt(contract.storage, namespaceId, issue.table);
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: issue.table,
+    });
     return {
       namespaceId,
       ...ifDefined('explicitNodeControlPolicy', table?.control),

package/src/core/migrations/issue-planner.ts

@@ -81,7 +81,7 @@ function locateNamespaceTypeInStorage(
   typeName: string,
 ): unknown {
   const ns = storage.namespaces[namespaceId];
-  return isPostgresSchema(ns) ? ns.entries.type[typeName] : undefined;
+  return isPostgresSchema(ns) ? ns.type[typeName] : undefined;
 }
 
 // ============================================================================

package/src/core/migrations/planner-strategies.ts

@@ -97,9 +97,9 @@ export function tableAt(
   namespaceId: string,
   tableName: string,
 ): StorageTable | undefined {
-  // Namespace.tables is typed as Record<string, IRNode> at the interface level;
-  // SQL family namespaces always hold StorageTable instances.
-  return storage.namespaces[namespaceId]?.entries.table[tableName] as StorageTable | undefined;
+  const ns = storage.namespaces[namespaceId];
+  if (ns === undefined) return undefined;
+  return ns.entries.table?.[tableName];
 }
 
 /**
@@ -141,7 +141,7 @@ const DEFAULT_ENUM_NAMESPACE_ID = 'public';
 function namespaceHasEnum(storage: SqlStorage, namespaceId: string, typeName: string): boolean {
   const ns = storage.namespaces[namespaceId];
   if (!isPostgresSchema(ns)) return false;
-  return ns.entries.type[typeName] !== undefined;
+  return ns.type[typeName] !== undefined;
 }
 
 /**
@@ -463,8 +463,7 @@ function enumRebuildCallRecipe(
   // same-named enums in distinct namespaces keep their columns disjoint.
   const columnRefs: { namespaceId: string; table: string; column: string }[] = [];
   for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {
-    for (const [tableName, tableNode] of Object.entries(ns.entries.table)) {
-      const table = tableNode as StorageTable;
+    for (const [tableName, table] of Object.entries(ns.entries.table ?? {})) {
       for (const [columnName, column] of Object.entries(table.columns)) {
         if (
           column.typeRef === typeName &&
@@ -667,9 +666,7 @@ function collectPostgresEnumTypes(storage: SqlStorage): ReadonlyMap<string, Post
   const result = new Map<string, PostgresEnumType>();
   for (const [nsId, ns] of Object.entries(storage.namespaces)) {
     if (!isPostgresSchema(ns)) continue;
-    for (const [name, instance] of Object.entries(ns.entries.type).sort(([a], [b]) =>
-      a.localeCompare(b),
-    )) {
+    for (const [name, instance] of Object.entries(ns.type).sort(([a], [b]) => a.localeCompare(b))) {
       if (instance instanceof PostgresEnumType) {
         result.set(enumCompoundKey(nsId, name), instance);
       }
@@ -688,7 +685,7 @@ function collectContractChecks(
   tableName: string,
 ): ReadonlyArray<{ name: string; column: string; permittedValues: readonly string[] }> {
   const ns = storage.namespaces[namespaceId];
-  const tableRaw = ns?.entries.table[tableName];
+  const tableRaw = ns !== undefined ? ns.entries.table?.[tableName] : undefined;
   if (!(tableRaw instanceof StorageTable)) return [];
   const checks = tableRaw.checks;
   if (!checks || checks.length === 0) return [];
@@ -734,7 +731,7 @@ export const checkConstraintPlanCallStrategy: CallMigrationStrategy = (issues, c
   const handledIssueKeys = new Set<string>();
 
   for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {
-    for (const tableName of Object.keys(ns.entries.table)) {
+    for (const tableName of Object.keys(ns.entries.table ?? {})) {
       const contractChecks = collectContractChecks(ctx.toContract.storage, namespaceId, tableName);
       if (contractChecks.length === 0) continue;
 

package/src/core/postgres-contract-serializer.ts

@@ -15,11 +15,12 @@ import {
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
-import { blindCast } from '@prisma-next/utils/casts';
+import { blindCast, castAs } from '@prisma-next/utils/casts';
 import type { JsonObject } from '@prisma-next/utils/json';
 import type { Type } from 'arktype';
 import { postgresAuthoringEntityTypes } from './authoring';
 import type { PostgresEnumType } from './postgres-enum-type';
+import { PostgresEnumTypeSchema } from './postgres-enum-type-schema';
 import { isPostgresSchema, PostgresSchema } from './postgres-schema';
 
 const POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {
@@ -38,27 +39,21 @@ function isAuthoringEntityTypeFactoryOutput(
 }
 
 /**
- * Walks a pack's entity-type namespace tree and emits the maps the
- * family base consumes — hydrators and validator-schema fragments, both
- * keyed by the descriptor's `discriminator`.
+ * Walks a pack's entity-type namespace tree and emits hydration factories
+ * keyed by the descriptor's `discriminator`. Used for `storage.types`
+ * (codec-triple hydration). Namespace entries hydration dispatches by
+ * entries key, not discriminator — handled by `hydrateEntriesKind`.
  */
-function collectEntityRegistryContributions(namespace: AuthoringEntityTypeNamespace): {
-  readonly entityTypeRegistry: ReadonlyMap<string, SqlEntityHydrationFactory>;
-  readonly validatorFragments: ReadonlyMap<string, Type<unknown>>;
-} {
-  const entityTypeRegistry = new Map<string, SqlEntityHydrationFactory>();
-  const validatorFragments = new Map<string, Type<unknown>>();
+function collectStorageTypesHydrators(
+  namespace: AuthoringEntityTypeNamespace,
+): ReadonlyMap<string, SqlEntityHydrationFactory> {
+  const registry = new Map<string, SqlEntityHydrationFactory>();
   const walk = (node: AuthoringEntityTypeNamespace): void => {
     for (const value of Object.values(node)) {
       if (isAuthoringEntityTypeDescriptor(value)) {
         if (isAuthoringEntityTypeFactoryOutput(value.output)) {
           const { factory } = value.output;
-          entityTypeRegistry.set(value.discriminator, (raw) =>
-            factory(raw, POSTGRES_AUTHORING_CTX),
-          );
-        }
-        if (value.validatorSchema !== undefined) {
-          validatorFragments.set(value.discriminator, value.validatorSchema);
+          registry.set(value.discriminator, (raw) => factory(raw, POSTGRES_AUTHORING_CTX));
         }
         continue;
       }
@@ -68,15 +63,47 @@ function collectEntityRegistryContributions(namespace: AuthoringEntityTypeNamesp
     }
   };
   walk(namespace);
-  return { entityTypeRegistry, validatorFragments };
+  return registry;
 }
 
+// Pack-contributed validator schemas keyed by entries key: postgres registers
+// 'type' → the inner name→entry map schema. The family base composes these
+// into the single registry alongside SQL core's 'table'/'valueSet' via
+// createSqlEntrySchemaRegistry.
+const POSTGRES_VALIDATOR_REGISTRY: ReadonlyMap<string, Type<unknown>> = new Map<
+  string,
+  Type<unknown>
+>([['type', castAs<Type<unknown>>(PostgresEnumTypeSchema)]]);
+
 export class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
+  private readonly enumFactory: SqlEntityHydrationFactory | undefined;
+
   constructor() {
-    const { entityTypeRegistry, validatorFragments } = collectEntityRegistryContributions(
-      postgresAuthoringEntityTypes,
-    );
-    super(entityTypeRegistry, validatorFragments);
+    const storageTypesHydrators = collectStorageTypesHydrators(postgresAuthoringEntityTypes);
+    super(storageTypesHydrators, POSTGRES_VALIDATOR_REGISTRY);
+    this.enumFactory = storageTypesHydrators.get('postgres-enum');
+  }
+
+  protected override hydrateEntriesKind(
+    key: string,
+    innerMap: unknown,
+  ): Record<string, unknown> | undefined {
+    if (key === 'type') {
+      if (innerMap === null || typeof innerMap !== 'object' || Array.isArray(innerMap)) {
+        return {};
+      }
+      return Object.fromEntries(
+        Object.entries(
+          blindCast<Record<string, unknown>, 'checked object, non-null, non-array above'>(innerMap),
+        ).map(([name, entry]) => [
+          name,
+          blindCast<PostgresEnumType, 'postgres-enum factory returns PostgresEnumType'>(
+            this.enumFactory !== undefined ? this.enumFactory(entry) : entry,
+          ),
+        ]),
+      );
+    }
+    return super.hydrateEntriesKind(key, innerMap);
   }
 
   protected override hydrateSqlNamespaceEntry(
@@ -88,43 +115,38 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     }
     const hydrated = blindCast<
       SqlNamespaceTablesInput,
-      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'
+      'super.hydrateSqlNamespaceEntry returns SqlNamespaceTablesInput when raw is not a NamespaceBase'
     >(super.hydrateSqlNamespaceEntry(nsId, raw));
     const { id, entries } = hydrated;
 
-    // Extract the postgres-specific `type` slot directly from raw input.
-    // The family base handles the `table` slot; the postgres target owns `type`.
-    const rawRecord = raw as Record<string, unknown>;
-    const rawEntries = rawRecord['entries'];
-    let typeSlot: Record<string, PostgresEnumType> | undefined;
-    if (rawEntries !== null && typeof rawEntries === 'object' && !Array.isArray(rawEntries)) {
-      const rawTypeSlot = (rawEntries as Record<string, unknown>)['type'];
-      if (rawTypeSlot !== null && typeof rawTypeSlot === 'object' && !Array.isArray(rawTypeSlot)) {
-        const enumFactory = this.entityTypeRegistry.get('postgres-enum');
-        typeSlot = Object.fromEntries(
-          Object.entries(rawTypeSlot as Record<string, unknown>).map(([name, entry]) => [
-            name,
-            blindCast<PostgresEnumType, 'postgres-enum factory returns PostgresEnumType'>(
-              enumFactory !== undefined ? enumFactory(entry) : entry,
-            ),
-          ]),
-        );
-      }
-    }
-
-    const valueSetSlot = entries.valueSet;
-    const hasValueSets = valueSetSlot !== undefined && Object.keys(valueSetSlot).length > 0;
-    const emptyTables = Object.keys(entries.table).length === 0;
-    const emptyTypes = !typeSlot || Object.keys(typeSlot).length === 0;
+    const typeEntries = blindCast<
+      Record<string, PostgresEnumType> | undefined,
+      'hydrateEntriesKind populates entries[type] with PostgresEnumType instances'
+    >(entries['type']);
+    const valueSetEntries = entries['valueSet'];
+    const hasValueSets = valueSetEntries !== undefined && Object.keys(valueSetEntries).length > 0;
+    const tableEntries = entries['table'] ?? {};
+    const emptyTables = Object.keys(tableEntries).length === 0;
+    const emptyTypes = !typeEntries || Object.keys(typeEntries).length === 0;
     if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes && !hasValueSets) {
       return PostgresSchema.unbound;
     }
     return new PostgresSchema({
       id,
       entries: {
-        table: entries.table,
-        type: typeSlot ?? {},
-        ...(hasValueSets ? { valueSet: valueSetSlot } : {}),
+        table: blindCast<
+          Record<string, unknown>,
+          'table entries are StorageTable instances after base hydration'
+        >(tableEntries),
+        type: typeEntries ?? {},
+        ...(hasValueSets
+          ? {
+              valueSet: blindCast<
+                Record<string, unknown>,
+                'valueSet entries are StorageValueSet instances after base hydration'
+              >(valueSetEntries),
+            }
+          : {}),
       },
     });
   }
@@ -142,7 +164,7 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
           kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
           entries: {
             table: Object.fromEntries(
-              Object.entries(ns.entries.table).map(([tableName, table]) => [
+              Object.entries(ns.entries.table ?? {}).map(([tableName, table]) => [
                 tableName,
                 this.serializeJsonValue(table) as JsonObject,
               ]),
@@ -170,14 +192,14 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
 
   private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {
     const tablesOut: Record<string, JsonObject> = {};
-    for (const [tableName, table] of Object.entries(ns.entries.table)) {
+    for (const [tableName, table] of Object.entries(ns.table)) {
       tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;
     }
     const typeOut: Record<string, JsonObject> = {};
-    for (const [typeName, ty] of Object.entries(ns.entries.type)) {
+    for (const [typeName, ty] of Object.entries(ns.type)) {
       typeOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
     }
-    const valueSetEntries = ns.entries.valueSet;
+    const valueSetEntries = ns.valueSet;
     const valueSetOut: Record<string, JsonObject> = {};
     if (valueSetEntries !== undefined) {
       for (const [valueSetName, valueSet] of Object.entries(valueSetEntries)) {

package/src/core/postgres-enum-type-schema.ts

@@ -0,0 +1,17 @@
+import { type } from 'arktype';
+
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+
+/**
+ * Arktype validator for a `postgres-enum` entry under
+ * `storage.namespaces[id].entries.type[name]`. Registered by the Postgres
+ * target pack against the `'type'` entries key so the family-layer namespace
+ * validator accepts (and rejects) entries of this kind.
+ */
+export const PostgresEnumTypeSchema = type({
+  kind: "'postgres-enum'",
+  'name?': 'string',
+  'nativeType?': 'string',
+  values: type.string.array().readonly(),
+  'control?': ControlPolicySchema,
+});