@prisma-next/target-postgres 0.14.0-dev.6 → 0.14.0-dev.61

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

@@ -10,20 +10,27 @@ import {
   isAuthoringEntityTypeDescriptor,
 } from '@prisma-next/framework-components/authoring';
 import {
+  type AnyEntityKindDescriptor,
   type Namespace,
-  NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlNamespaceInput, SqlStorage } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import type { JsonObject } from '@prisma-next/utils/json';
 import { postgresAuthoringEntityTypes } from './authoring';
-import { postgresTargetDescriptorMeta } from './descriptor-meta';
-import { isPostgresSchema, PostgresSchema } from './postgres-schema';
+import { PG_INT_CODEC_ID, PG_TEXT_CODEC_ID } from './codec-ids';
+import {
+  nativeEnumEntityKind,
+  policyEntityKind,
+  rlsEnablementEntityKind,
+  roleEntityKind,
+} from './entity-kinds';
+import { PostgresSchema } from './postgres-schema';
 
 const POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {
   family: 'sql',
   target: 'postgres',
+  enumInferenceCodecs: { text: PG_TEXT_CODEC_ID, int: PG_INT_CODEC_ID },
 };
 
 function isAuthoringEntityTypeFactoryOutput(
@@ -32,7 +39,8 @@ function isAuthoringEntityTypeFactoryOutput(
   return (
     typeof output === 'object' &&
     output !== null &&
-    typeof (output as AuthoringEntityTypeFactoryOutput).factory === 'function'
+    'factory' in output &&
+    typeof output.factory === 'function'
   );
 }
 
@@ -65,34 +73,35 @@ function collectStorageTypesHydrators(
 }
 
 export class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
-  constructor() {
+  constructor(extraPackEntityKinds: readonly AnyEntityKindDescriptor[] = []) {
     const storageTypesHydrators = collectStorageTypesHydrators(postgresAuthoringEntityTypes);
-    super(storageTypesHydrators);
-  }
-
-  protected override get defaultNamespaceId(): string {
-    return postgresTargetDescriptorMeta.defaultNamespaceId;
+    super(storageTypesHydrators, [
+      policyEntityKind,
+      roleEntityKind,
+      rlsEnablementEntityKind,
+      nativeEnumEntityKind,
+      ...extraPackEntityKinds,
+    ]);
   }
 
   protected override hydrateSqlNamespaceEntry(
     nsId: string,
-    raw: Namespace | Record<string, unknown>,
-  ): Namespace | SqlNamespaceTablesInput {
-    if (raw instanceof NamespaceBase) {
-      return raw;
-    }
+    raw: Record<string, unknown>,
+  ): Namespace | SqlNamespaceInput {
     const hydrated = blindCast<
-      SqlNamespaceTablesInput,
-      'super.hydrateSqlNamespaceEntry returns SqlNamespaceTablesInput when raw is not a NamespaceBase'
+      SqlNamespaceInput,
+      'raw is always plain JSON, so super.hydrateSqlNamespaceEntry returns SqlNamespaceInput'
     >(super.hydrateSqlNamespaceEntry(nsId, raw));
     const { id, entries } = hydrated;
 
-    const valueSetSlot = entries['valueSet'];
-    const hasValueSets = valueSetSlot !== undefined && Object.keys(valueSetSlot).length > 0;
-    const emptyTables = Object.keys(entries['table'] ?? {}).length === 0;
-    if (id === UNBOUND_NAMESPACE_ID && emptyTables && !hasValueSets) {
+    const allSlotsEmpty = Object.values(entries).every(
+      (slot) => slot === undefined || Object.keys(slot).length === 0,
+    );
+    if (id === UNBOUND_NAMESPACE_ID && allSlotsEmpty) {
       return PostgresSchema.unbound;
     }
+    const valueSetSlot = entries['valueSet'];
+    const hasValueSets = valueSetSlot !== undefined && Object.keys(valueSetSlot).length > 0;
     return new PostgresSchema({
       id,
       entries: {
@@ -106,24 +115,16 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
   override serializeContract(contract: Contract<SqlStorage>): JsonObject {
     const { storage, ...rest } = contract;
     const namespacesJson: Record<string, JsonObject> = {};
+    // Each namespace serializes to its id, its schema-kind tag, and the
+    // base's generic entries walk — every enumerable kind on
+    // `PostgresSchema.entries`, including `native_enum`.
     for (const [nsId, ns] of Object.entries(storage.namespaces)) {
-      if (isPostgresSchema(ns)) {
-        namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
-      } else {
-        const isUnboundSlot = nsId === UNBOUND_NAMESPACE_ID;
-        namespacesJson[nsId] = {
-          id: nsId,
-          kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
-          entries: {
-            table: Object.fromEntries(
-              Object.entries(ns.entries.table ?? {}).map(([tableName, table]) => [
-                tableName,
-                this.serializeJsonValue(table) as JsonObject,
-              ]),
-            ),
-          },
-        };
-      }
+      const isUnboundSlot = ns.id === UNBOUND_NAMESPACE_ID;
+      namespacesJson[nsId] = {
+        id: ns.id,
+        kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
+        entries: this.serializeNamespaceEntries(ns.entries),
+      };
     }
     const storageOut: Record<string, unknown> = {
       storageHash: String(storage.storageHash),
@@ -132,42 +133,16 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     if (storage.types !== undefined) {
       const typesOut: Record<string, JsonObject> = {};
       for (const [name, entry] of Object.entries(storage.types)) {
-        typesOut[name] = this.serializeJsonValue(entry) as JsonObject;
+        typesOut[name] = this.serializeJsonObject(entry);
       }
       storageOut['types'] = typesOut;
     }
-    return {
+    return blindCast<
+      JsonObject,
+      'contract minus storage plus a JSON-shaped storageOut is a JsonObject'
+    >({
       ...rest,
       storage: storageOut,
-    } as unknown as JsonObject;
-  }
-
-  private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {
-    const tablesOut: Record<string, JsonObject> = {};
-    for (const [tableName, table] of Object.entries(ns.table)) {
-      tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;
-    }
-    const valueSetEntries = ns.valueSet;
-    const valueSetOut: Record<string, JsonObject> = {};
-    if (valueSetEntries !== undefined) {
-      for (const [valueSetName, valueSet] of Object.entries(valueSetEntries)) {
-        valueSetOut[valueSetName] = blindCast<
-          JsonObject,
-          'serializeJsonValue round-trips the value-set node through JSON, yielding a JsonObject'
-        >(this.serializeJsonValue(valueSet));
-      }
-    }
-    return {
-      id: ns.id,
-      kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
-      entries: {
-        table: tablesOut,
-        ...(Object.keys(valueSetOut).length > 0 ? { valueSet: valueSetOut } : {}),
-      },
-    };
-  }
-
-  private serializeJsonValue(value: unknown): unknown {
-    return JSON.parse(JSON.stringify(value)) as unknown;
+    });
   }
 }

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

@@ -0,0 +1,48 @@
+import type { Contract } from '@prisma-next/contract/types';
+import {
+  buildSqlSchemaQualifiedView,
+  type SqlSchemaQualifiedView,
+} from '@prisma-next/sql-contract/contract-view';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { PostgresContractSerializer } from './postgres-contract-serializer';
+
+/**
+ * A schema-qualified Postgres contract view: the deserialized contract
+ * intersected with a single `namespace` member holding every schema by id. It is
+ * substitutable for `Contract` (carries `storage`, `domain`, …) and reaches each
+ * schema's entities through `view.namespace.<schema>`:
+ *
+ * ```ts
+ * const view = PostgresContractView.fromJson<Contract>(contractJson);
+ * view.namespace.public.table.users      // typed table leaf in the public schema
+ * view.namespace.auth.table.users        // the auth schema's own users table
+ * view.namespace.public.entries.policy.X // pack-contributed kind (RLS / #771 path)
+ * view.namespace.__unbound__.table.X     // default schema, keyed by its raw id
+ * view.storage                           // the full contract is still present
+ * ```
+ *
+ * This mirrors the runtime `db.enums.<ns>` keying exactly (the default schema
+ * keeps its literal `__unbound__` id). Schema names are NOT promoted to the
+ * contract root, so there is no collision with contract envelope fields — a
+ * schema named `storage` is `view.namespace.storage`, while `view.storage`
+ * stays the contract's `storage`.
+ */
+export type PostgresContractView<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> =
+  SqlSchemaQualifiedView<TContract>;
+
+export const PostgresContractView = {
+  /** Wrap an already-deserialized Postgres contract in a schema-qualified view. */
+  from<TContract extends Contract<SqlStorage>>(
+    contract: TContract,
+  ): PostgresContractView<TContract> {
+    return buildSqlSchemaQualifiedView(contract);
+  },
+
+  /** Deserialize a Postgres contract JSON envelope and wrap it in a view. */
+  fromJson<TContract extends Contract<SqlStorage> = Contract<SqlStorage>>(
+    json: unknown,
+  ): PostgresContractView<TContract> {
+    const contract = new PostgresContractSerializer().deserializeContract<TContract>(json);
+    return buildSqlSchemaQualifiedView(contract);
+  },
+};

package/src/core/postgres-native-enum.ts

@@ -0,0 +1,51 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from '@prisma-next/sql-contract/types';
+
+export interface PostgresNativeEnumInput {
+  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */
+  readonly typeName: string;
+  /** Member values in declaration order — this is the Postgres enum sort order. */
+  readonly members: readonly string[];
+  readonly control?: ControlPolicy;
+}
+
+/**
+ * Postgres contract-IR class for a native enum type (`CREATE TYPE … AS ENUM (…)`).
+ *
+ * This is an authored, serialized Contract-IR entity — it is registered as an entity
+ * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+ * the schema-diff tree will use `PostgresNativeEnumSchemaNode` when the managed phase
+ * builds it.
+ *
+ * A member is a value, not a name→value pair — matching `CREATE TYPE … AS ENUM
+ * ('a', 'b')`, which has no separate member name.
+ *
+ * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly,
+ * frozen at construction via `freezeNode(this)`. The `kind: 'postgres-enum'`
+ * discriminant is enumerable so it survives JSON. Lives at
+ * `storage.namespaces[ns].entries.native_enum[HandleName]`; the entries key
+ * (`native_enum`) is the entity-kind descriptor's `kind`, decoupled from this
+ * node's own `kind` literal — the same shape as `table`/`StorageTable` and
+ * `valueSet`/`StorageValueSet`.
+ */
+export class PostgresNativeEnum extends SqlNode {
+  static is(node: unknown): node is PostgresNativeEnum {
+    return (
+      typeof node === 'object' && node !== null && 'kind' in node && node.kind === 'postgres-enum'
+    );
+  }
+
+  override readonly kind = 'postgres-enum' as const;
+  readonly typeName: string;
+  readonly members: readonly string[];
+  declare readonly control?: ControlPolicy;
+
+  constructor(input: PostgresNativeEnumInput) {
+    super();
+    this.typeName = input.typeName;
+    this.members = Object.freeze([...input.members]);
+    if (input.control !== undefined) this.control = input.control;
+    freezeNode(this);
+  }
+}

package/src/core/postgres-rls-enablement.ts

@@ -0,0 +1,34 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from '@prisma-next/sql-contract/types';
+
+export interface PostgresRlsEnablementInput {
+  /** Name of the table this marker declares RLS-controlled. */
+  readonly tableName: string;
+  /** Namespace coordinate (schema name). Markers are schema-scoped like policies. */
+  readonly namespaceId: string;
+}
+
+/**
+ * Postgres contract-IR marker for `@@rls` on a model: the table named here is
+ * RLS-controlled (`ENABLE ROW LEVEL SECURITY` is driven by this marker, never
+ * by the policy set).
+ *
+ * This is an authored, serialized Contract-IR entity — it is registered as an
+ * entity kind, extends `SqlNode`, and is stored in `contract.json` under
+ * `entries.rls[tableName]`. Target-only concept — no SQL-family abstract.
+ * Frozen at construction via `freezeNode(this)`. The `kind: 'rls'`
+ * discriminant is enumerable so it survives JSON serialization; the literal
+ * matches the entries key (one-string rule).
+ */
+export class PostgresRlsEnablement extends SqlNode {
+  override readonly kind = 'rls' as const;
+  readonly tableName: string;
+  readonly namespaceId: string;
+
+  constructor(input: PostgresRlsEnablementInput) {
+    super();
+    this.tableName = input.tableName;
+    this.namespaceId = input.namespaceId;
+    freezeNode(this);
+  }
+}

package/src/core/postgres-rls-policy.ts

@@ -0,0 +1,64 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from '@prisma-next/sql-contract/types';
+
+export type RlsPolicyOperation = 'select' | 'insert' | 'update' | 'delete' | 'all';
+
+export interface PostgresRlsPolicyInput {
+  /** Full wire name: `<prefix>_<8hex>`. Stored as-is; hashing is not this class's job. */
+  readonly name: string;
+  /** User-supplied prefix (the part before the `_<8hex>` suffix). */
+  readonly prefix: string;
+  /** Name of the table this policy attaches to, by name within the same schema. */
+  readonly tableName: string;
+  /** Namespace coordinate (schema name). Policies are schema-scoped. */
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  /** Sorted role names rendered in `TO <roles>`. Plain strings in this slice. */
+  readonly roles: readonly string[];
+  /** USING predicate SQL string, if present. */
+  readonly using?: string;
+  /** WITH CHECK predicate SQL string, if present. */
+  readonly withCheck?: string;
+  /** `true` = `AS PERMISSIVE`, `false` = `AS RESTRICTIVE`. */
+  readonly permissive: boolean;
+}
+
+/**
+ * Postgres contract-IR class for a row-level security policy (`CREATE POLICY … ON …`).
+ *
+ * This is an authored, serialized Contract-IR entity — it is registered as an entity
+ * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+ * the schema-diff tree uses `PostgresPolicySchemaNode` for that role.
+ *
+ * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly.
+ * Frozen at construction via `freezeNode(this)`. The `kind: 'policy'`
+ * discriminant is enumerable (overrides SqlNode's non-enumerable `'sql'`) so it
+ * survives JSON serialization and enables dispatch. The literal matches the
+ * entries key (one-string rule: node.kind === entries key === entity kind).
+ */
+export class PostgresRlsPolicy extends SqlNode {
+  override readonly kind = 'policy' as const;
+  readonly name: string;
+  readonly prefix: string;
+  readonly tableName: string;
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  readonly roles: readonly string[];
+  declare readonly using?: string;
+  declare readonly withCheck?: string;
+  readonly permissive: boolean;
+
+  constructor(input: PostgresRlsPolicyInput) {
+    super();
+    this.name = input.name;
+    this.prefix = input.prefix;
+    this.tableName = input.tableName;
+    this.namespaceId = input.namespaceId;
+    this.operation = input.operation;
+    this.roles = Object.freeze([...input.roles]);
+    if (input.using !== undefined) this.using = input.using;
+    if (input.withCheck !== undefined) this.withCheck = input.withCheck;
+    this.permissive = input.permissive;
+    freezeNode(this);
+  }
+}

package/src/core/postgres-role.ts

@@ -0,0 +1,59 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from '@prisma-next/sql-contract/types';
+
+/**
+ * Roles are referenced by the contract but never owned — the framework
+ * issues no `CREATE`/`DROP ROLE`, so a role's effective governance is always
+ * `external`: a missing declared role fails verify, an extra live role is
+ * tolerated, and the planner emits zero role DDL. `external` is the only
+ * value a role's control can ever carry.
+ */
+export const ROLE_DEFAULT_CONTROL_POLICY = 'external';
+
+export interface PostgresRoleInput {
+  readonly name: string;
+  /**
+   * Namespace coordinate. Roles are cluster-scoped; pass `UNBOUND_NAMESPACE_ID`
+   * from `@prisma-next/framework-components/ir`.
+   */
+  readonly namespaceId: string;
+  /**
+   * Defaults to {@link ROLE_DEFAULT_CONTROL_POLICY} when omitted. Roles are
+   * referenced but never owned, so `'external'` is the only allowed value.
+   */
+  readonly control?: 'external';
+}
+
+/**
+ * Postgres contract-IR class for a database role (`CREATE ROLE …`).
+ *
+ * This is an authored, serialized Contract-IR entity — it is registered as an entity
+ * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+ * the schema-diff tree uses `PostgresRoleSchemaNode` for that role.
+ *
+ * Roles are cluster-scoped, so their namespace coordinate is always
+ * `UNBOUND_NAMESPACE_ID`. Target-only concept — no SQL-family abstract.
+ * Extends `SqlNode` directly, frozen at construction via `freezeNode(this)`.
+ * The `kind: 'role'` discriminant is enumerable so it survives JSON.
+ * Matches the entries key (one-string rule).
+ *
+ * `control` always carries a value (never omitted): it defaults to
+ * {@link ROLE_DEFAULT_CONTROL_POLICY} in the constructor, so both a
+ * freshly-authored role and one hydrated from an older `contract.json`
+ * lacking the field resolve the same way — the control-policy resolver
+ * reads it directly off the entity instead of special-casing role issues.
+ */
+export class PostgresRole extends SqlNode {
+  override readonly kind = 'role' as const;
+  readonly name: string;
+  readonly namespaceId: string;
+  readonly control: 'external';
+
+  constructor(input: PostgresRoleInput) {
+    super();
+    this.name = input.name;
+    this.namespaceId = input.namespaceId;
+    this.control = input.control ?? ROLE_DEFAULT_CONTROL_POLICY;
+    freezeNode(this);
+  }
+}

package/src/core/postgres-schema-verifier.ts

@@ -1,16 +1,19 @@
 import type { Contract } from '@prisma-next/contract/types';
 import { SqlSchemaVerifierBase } from '@prisma-next/family-sql/ir';
-import type { SchemaIssue, SchemaVerifyOptions } from '@prisma-next/framework-components/control';
+import type {
+  SchemaDiffIssue,
+  SchemaVerifyOptions,
+} from '@prisma-next/framework-components/control';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 
 /**
  * Postgres target `SchemaVerifier` concretion. Plugs into the
  * SQL-shared verification surface; production verification today still
- * routes through the legacy `verifySqlSchema` entry point, which
- * carries options (codec hooks, normalizers, framework components)
- * that the framework-level `SchemaVerifyOptions` shape does not yet
- * surface.
+ * routes through the family verify verdict (`verifySqlSchemaByDiff` over
+ * `diffPostgresSchema`), which carries options (codec hooks,
+ * normalizers, framework components) that the framework-level
+ * `SchemaVerifyOptions` shape does not yet surface.
  *
  * The hooks return the empty list pending the call-site migration that
  * routes the existing verifier behaviour through the SPI — at that
@@ -25,13 +28,13 @@ export class PostgresSchemaVerifier extends SqlSchemaVerifierBase<
 > {
   protected verifyCommonSqlSchema(
     _options: SchemaVerifyOptions<Contract<SqlStorage>, SqlSchemaIR>,
-  ): readonly SchemaIssue[] {
+  ): readonly SchemaDiffIssue[] {
     return [];
   }
 
   protected verifyTargetExtensions(
     _options: SchemaVerifyOptions<Contract<SqlStorage>, SqlSchemaIR>,
-  ): readonly SchemaIssue[] {
+  ): readonly SchemaDiffIssue[] {
     return [];
   }
 }

package/src/core/postgres-schema.ts

@@ -1,24 +1,45 @@
+import type { Contract } from '@prisma-next/contract/types';
 import {
   freezeNode,
   hydrateNamespaceEntities,
-  NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';
-import type {
-  SqlNamespaceEntries,
-  SqlNamespaceTablesInput,
-  SqlStorage,
-  StorageTable,
-  StorageValueSet,
+import {
+  SqlNamespaceBase,
+  type SqlNamespaceEntries,
+  type SqlNamespaceInput,
+  type SqlStorage,
+  type StorageTable,
+  type StorageValueSet,
 } from '@prisma-next/sql-contract/types';
+
 import { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresTableSource } from './ast/table-source';
 import { PG_TEXT_CODEC_ID } from './codec-ids';
+import {
+  nativeEnumEntityKind,
+  policyEntityKind,
+  rlsEnablementEntityKind,
+  roleEntityKind,
+} from './entity-kinds';
+import type { PostgresNativeEnum } from './postgres-native-enum';
+import type { PostgresRlsEnablement } from './postgres-rls-enablement';
+import type { PostgresRlsPolicy } from './postgres-rls-policy';
+import type { PostgresRole } from './postgres-role';
 import { escapeLiteral } from './sql-utils';
 
+export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };
+
+export type PostgresNamespaceEntries = SqlNamespaceEntries & {
+  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
+  readonly role?: Readonly<Record<string, PostgresRole>>;
+  readonly rls?: Readonly<Record<string, PostgresRlsEnablement>>;
+  readonly native_enum?: Readonly<Record<string, PostgresNativeEnum>>;
+};
+
 export interface PostgresSchemaInput {
   readonly id: string;
   readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
@@ -38,7 +59,7 @@ export interface PostgresSchemaInput {
  * prefix entirely — call sites stay polymorphic and never branch on
  * `id === UNBOUND_NAMESPACE_ID`.
  */
-export class PostgresSchema extends NamespaceBase {
+export class PostgresSchema extends SqlNamespaceBase {
   /**
    * Stable singleton reference for the late-bound slot. Materialised
    * lazily below the singleton subclass declaration so the static
@@ -50,13 +71,22 @@ export class PostgresSchema extends NamespaceBase {
 
   declare readonly kind: 'schema';
   readonly id: string;
-  readonly entries: SqlNamespaceEntries;
+  readonly entries: PostgresNamespaceEntries;
 
   constructor(input: PostgresSchemaInput) {
     super();
     this.id = input.id;
 
-    const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), 'carry');
+    const dispatched = hydrateNamespaceEntities(
+      input.entries,
+      composeSqlEntityKinds([
+        policyEntityKind,
+        roleEntityKind,
+        rlsEnablementEntityKind,
+        nativeEnumEntityKind,
+      ]),
+      'carry',
+    );
 
     // Drop an empty valueSet so presence signals non-emptiness.
     const valueSetRaw = dispatched['valueSet'];
@@ -65,11 +95,15 @@ export class PostgresSchema extends NamespaceBase {
         ? { ...dispatched, valueSet: undefined }
         : dispatched;
 
+    const entriesInput: Record<string, Readonly<Record<string, unknown>> | undefined> = {
+      ...withPresence,
+    };
+
     this.entries = Object.freeze(
       blindCast<
-        SqlNamespaceEntries,
-        'composeSqlEntityKinds() supplies table→StorageTable and valueSet→StorageValueSet descriptors, so this open-dict result holds exactly the typed members SqlNamespaceEntries declares; the descriptor Map erases those per-kind Node types from the return.'
-      >(withPresence),
+        PostgresNamespaceEntries,
+        'composeSqlEntityKinds([policyEntityKind, roleEntityKind, rlsEnablementEntityKind, nativeEnumEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole, rls→PostgresRlsEnablement, native_enum→PostgresNativeEnum descriptors'
+      >(entriesInput),
     );
     Object.defineProperty(this, 'kind', {
       value: 'schema',
@@ -88,6 +122,18 @@ export class PostgresSchema extends NamespaceBase {
     return this.entries.valueSet;
   }
 
+  get policy(): Readonly<Record<string, PostgresRlsPolicy>> {
+    return this.entries.policy ?? Object.freeze({});
+  }
+
+  get role(): Readonly<Record<string, PostgresRole>> {
+    return this.entries.role ?? Object.freeze({});
+  }
+
+  get rls(): Readonly<Record<string, PostgresRlsEnablement>> {
+    return this.entries.rls ?? Object.freeze({});
+  }
+
   /**
    * The bare schema qualifier as it would appear in a rendered SQL
    * fragment (already quoted). The unbound-schema singleton overrides
@@ -245,9 +291,12 @@ export function isPostgresSchema(ns: unknown): ns is PostgresSchema {
  * The factory has no per-call state — every named id deterministically
  * maps to a distinct schema instance — so callers can pass it through
  * by reference and trust the resulting `SqlStorage.namespaces` map to
- * be value-stable for a given input set.
+ * be value-stable for a given input set. Native-enum column type names are
+ * schema-qualified earlier, at column construction, via the target's
+ * `authoring.qualifyColumnType` hook (`postgresQualifyColumnType`), so this
+ * factory just materialises the namespace from already-qualified entries.
  */
-export function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {
+export function postgresCreateNamespace(input: SqlNamespaceInput): PostgresSchema {
   const schemaInput: PostgresSchemaInput = {
     id: input.id,
     entries: {

package/src/core/postgres-validators.ts

@@ -0,0 +1,34 @@
+import { type } from 'arktype';
+
+export const PostgresRoleSchema = type({
+  kind: "'role'",
+  name: 'string',
+  namespaceId: 'string',
+  'control?': "'external'",
+});
+
+export const PostgresRlsPolicySchema = type({
+  kind: "'policy'",
+  name: 'string',
+  prefix: 'string',
+  tableName: 'string',
+  namespaceId: 'string',
+  operation: "'select' | 'insert' | 'update' | 'delete' | 'all'",
+  roles: type.string.array().readonly(),
+  'using?': 'string',
+  'withCheck?': 'string',
+  permissive: 'boolean',
+});
+
+export const PostgresRlsEnablementSchema = type({
+  kind: "'rls'",
+  tableName: 'string',
+  namespaceId: 'string',
+});
+
+export const PostgresNativeEnumSchema = type({
+  kind: "'postgres-enum'",
+  typeName: 'string',
+  members: type.string.array().readonly(),
+  'control?': "'managed' | 'tolerated' | 'external' | 'observed'",
+});