@prisma-next/target-postgres 0.14.0-dev.2 → 0.14.0-dev.20

package/dist/postgres-schema-BVDr_61a.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-BVDr_61a.mjs","names":[],"sources":["../src/core/postgres-rls-policy.ts","../src/core/postgres-role.ts","../src/core/postgres-validators.ts","../src/core/ast/table-source.ts","../src/core/entity-kinds.ts","../src/core/postgres-schema.ts"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport type { EntityCoordinate } from '@prisma-next/framework-components/ir';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport type RlsPolicyOperation = 'select' | 'insert' | 'update' | 'delete' | 'all';\n\nexport interface PostgresRlsPolicyInput {\n  /** Full wire name: `<prefix>_<8hex>`. Stored as-is; hashing is not this class's job. */\n  readonly name: string;\n  /** User-supplied prefix (the part before the `_<8hex>` suffix). */\n  readonly prefix: string;\n  /** Name of the table this policy attaches to, by name within the same schema. */\n  readonly tableName: string;\n  /** Namespace coordinate (schema name). Policies are schema-scoped. */\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  /** Sorted role names rendered in `TO <roles>`. Plain strings in this slice. */\n  readonly roles: readonly string[];\n  /** USING predicate SQL string, if present. */\n  readonly using?: string;\n  /** WITH CHECK predicate SQL string, if present. */\n  readonly withCheck?: string;\n  /** `true` = `AS PERMISSIVE`, `false` = `AS RESTRICTIVE`. */\n  readonly permissive: boolean;\n}\n\n/**\n * Postgres IR class for a row-level security policy (`CREATE POLICY … ON …`).\n *\n * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly.\n * Frozen at construction via `freezeNode(this)`. The `kind: 'policy'`\n * discriminant is enumerable (overrides SqlNode's non-enumerable `'sql'`) so it\n * survives JSON serialization and enables dispatch. The literal matches the\n * entries key (one-string rule: node.kind === entries key === entity kind).\n */\nexport class PostgresRlsPolicy extends SqlNode implements DiffableNode {\n  override readonly kind = 'policy' as const;\n  readonly name: string;\n  readonly prefix: string;\n  readonly tableName: string;\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  readonly roles: readonly string[];\n  declare readonly using?: string;\n  declare readonly withCheck?: string;\n  readonly permissive: boolean;\n\n  constructor(input: PostgresRlsPolicyInput) {\n    super();\n    this.name = input.name;\n    this.prefix = input.prefix;\n    this.tableName = input.tableName;\n    this.namespaceId = input.namespaceId;\n    this.operation = input.operation;\n    this.roles = Object.freeze([...input.roles]);\n    if (input.using !== undefined) this.using = input.using;\n    if (input.withCheck !== undefined) this.withCheck = input.withCheck;\n    this.permissive = input.permissive;\n    freezeNode(this);\n  }\n\n  identity(): EntityCoordinate {\n    return {\n      plane: 'storage',\n      namespaceId: this.namespaceId,\n      entityKind: 'policy',\n      entityName: this.name,\n    };\n  }\n\n  /**\n   * Equality by wire name only. The wire name is `<prefix>_<sha256(body)[0..8]>`,\n   * so name-equality IS body-equality — two policies with different bodies\n   * have different hashes and therefore different names. We deliberately\n   * skip comparing bodies directly because Postgres reprints predicate\n   * expressions (e.g. strips outer parentheses), so a byte-compare against\n   * the authored body would produce false mismatches on a clean re-verify.\n   */\n  isEqualTo(other: DiffableNode): boolean {\n    if (!isPostgresRlsPolicy(other)) {\n      throw new Error(\n        `PostgresRlsPolicy.isEqualTo: expected a PostgresRlsPolicy, got ${other.identity().entityKind}`,\n      );\n    }\n    return this.name === other.name;\n  }\n}\n\nexport function isPostgresRlsPolicy(node: DiffableNode | undefined): node is PostgresRlsPolicy {\n  return node !== undefined && 'kind' in node && node.kind === 'policy';\n}\n\nexport function assertPostgresRlsPolicy(\n  node: DiffableNode | undefined,\n): asserts node is PostgresRlsPolicy {\n  if (!isPostgresRlsPolicy(node)) {\n    const kind = node !== undefined && 'kind' in node ? String(node.kind) : typeof node;\n    throw new Error(\n      `planRlsDiff: expected a PostgresRlsPolicy on the policy-diff path but got ${kind}`,\n    );\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport type { EntityCoordinate } from '@prisma-next/framework-components/ir';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresRoleInput {\n  readonly name: string;\n  /**\n   * Namespace coordinate. Roles are cluster-scoped; pass `UNBOUND_NAMESPACE_ID`\n   * from `@prisma-next/framework-components/ir`.\n   */\n  readonly namespaceId: string;\n}\n\n/**\n * Postgres IR class for a database role (`CREATE ROLE …`).\n *\n * Roles are cluster-scoped, so their namespace coordinate is always\n * `UNBOUND_NAMESPACE_ID`. Target-only concept — no SQL-family abstract.\n * Extends `SqlNode` directly, frozen at construction via `freezeNode(this)`.\n * The `kind: 'role'` discriminant is enumerable so it survives JSON.\n * Matches the entries key (one-string rule).\n */\nexport class PostgresRole extends SqlNode implements DiffableNode {\n  override readonly kind = 'role' as const;\n  readonly name: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRoleInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n\n  identity(): EntityCoordinate {\n    return {\n      plane: 'storage',\n      namespaceId: this.namespaceId,\n      entityKind: 'role',\n      entityName: this.name,\n    };\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    if (!(other instanceof PostgresRole)) {\n      throw new Error(\n        `PostgresRole.isEqualTo: expected a PostgresRole, got ${other.identity().entityKind}`,\n      );\n    }\n    return this.name === other.name;\n  }\n}\n","import { type } from 'arktype';\n\nexport const PostgresRoleSchema = type({\n  kind: \"'role'\",\n  name: 'string',\n  namespaceId: 'string',\n});\n\nexport const PostgresRlsPolicySchema = type({\n  kind: \"'policy'\",\n  name: 'string',\n  prefix: 'string',\n  tableName: 'string',\n  namespaceId: 'string',\n  operation: \"'select' | 'insert' | 'update' | 'delete' | 'all'\",\n  roles: type.string.array().readonly(),\n  'using?': 'string',\n  'withCheck?': 'string',\n  permissive: 'boolean',\n});\n","import {\n  type AnyFromSource,\n  type AstRewriter,\n  TableSource,\n} from '@prisma-next/sql-relational-core/ast';\n\nexport class PostgresTableSource extends TableSource {\n  readonly schema: string | undefined;\n\n  constructor(options: {\n    readonly name: string;\n    readonly schema?: string;\n    readonly alias?: string;\n  }) {\n    super(options.name, options.alias);\n    this.schema = options.schema;\n    this.freeze();\n  }\n\n  override rewrite(rewriter: AstRewriter): AnyFromSource {\n    return rewriter.tableSource ? rewriter.tableSource(this) : this;\n  }\n}\n","import type { EntityKindDescriptor } from '@prisma-next/framework-components/ir';\nimport { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';\n\nexport const policyEntityKind: EntityKindDescriptor<PostgresRlsPolicyInput, PostgresRlsPolicy> = {\n  kind: 'policy',\n  schema: PostgresRlsPolicySchema,\n  construct: (input) => new PostgresRlsPolicy(input),\n};\n\nexport const roleEntityKind: EntityKindDescriptor<PostgresRoleInput, PostgresRole> = {\n  kind: 'role',\n  schema: PostgresRoleSchema,\n  construct: (input) => new PostgresRole(input),\n};\n","import {\n  freezeNode,\n  hydrateNamespaceEntities,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';\nimport type {\n  SqlNamespaceEntries,\n  SqlNamespaceTablesInput,\n  SqlStorage,\n  StorageTable,\n  StorageValueSet,\n} from '@prisma-next/sql-contract/types';\nimport { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresTableSource } from './ast/table-source';\nimport { PG_TEXT_CODEC_ID } from './codec-ids';\nimport { policyEntityKind, roleEntityKind } from './entity-kinds';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './postgres-role';\nimport { escapeLiteral } from './sql-utils';\n\nexport type PostgresNamespaceEntries = SqlNamespaceEntries & {\n  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;\n  readonly role?: Readonly<Record<string, PostgresRole>>;\n};\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\n}\n\n/**\n * Postgres target `Namespace` concretion — a Postgres schema (`CREATE\n * SCHEMA …`). Each Postgres `SqlStorage` carries a\n * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by\n * the Postgres PSL interpreter from `namespace { … }` AST buckets.\n *\n * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier\n * emission is the rendering seam: DDL / SQL emission asks the namespace\n * for its qualifier (`\"<schema>\"`) or for a qualified table name\n * (`\"<schema>\".\"<table>\"`) and consumes the result polymorphically.\n * The unbound singleton below overrides these methods to elide the\n * prefix entirely — call sites stay polymorphic and never branch on\n * `id === UNBOUND_NAMESPACE_ID`.\n */\nexport class PostgresSchema extends NamespaceBase {\n  /**\n   * Stable singleton reference for the late-bound slot. Materialised\n   * lazily below the singleton subclass declaration so the static\n   * initialiser sees the subclass before assigning. Consumers always\n   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`\n   * — same identity).\n   */\n  static unbound: PostgresUnboundSchema;\n\n  declare readonly kind: 'schema';\n  readonly id: string;\n  readonly entries: PostgresNamespaceEntries;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n\n    const dispatched = hydrateNamespaceEntities(\n      input.entries,\n      composeSqlEntityKinds([policyEntityKind, roleEntityKind]),\n      'carry',\n    );\n\n    // Drop an empty valueSet so presence signals non-emptiness.\n    const valueSetRaw = dispatched['valueSet'];\n    const withPresence =\n      valueSetRaw !== undefined && Object.keys(valueSetRaw).length === 0\n        ? { ...dispatched, valueSet: undefined }\n        : dispatched;\n\n    this.entries = Object.freeze(\n      blindCast<\n        PostgresNamespaceEntries,\n        'composeSqlEntityKinds([policyEntityKind, roleEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole descriptors'\n      >(withPresence),\n    );\n    Object.defineProperty(this, 'kind', {\n      value: 'schema',\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries.table ?? Object.freeze({});\n  }\n\n  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {\n    return this.entries.valueSet;\n  }\n\n  get policy(): Readonly<Record<string, PostgresRlsPolicy>> {\n    return this.entries.policy ?? Object.freeze({});\n  }\n\n  get role(): Readonly<Record<string, PostgresRole>> {\n    return this.entries.role ?? Object.freeze({});\n  }\n\n  /**\n   * The bare schema qualifier as it would appear in a rendered SQL\n   * fragment (already quoted). The unbound-schema singleton overrides\n   * this to return `''`.\n   */\n  qualifier(): string {\n    return `\"${this.id}\"`;\n  }\n\n  /**\n   * Qualify a table name with the schema prefix\n   * (`\"<schema>\".\"<table>\"`). The unbound-schema singleton overrides\n   * this to emit just `\"<table>\"` so the resolved DDL is unqualified\n   * and `search_path` decides where the object lands at runtime.\n   */\n  qualifyTable(tableName: string): string {\n    return `\"${this.id}\".\"${tableName}\"`;\n  }\n\n  /**\n   * Render a SQL string-literal containing the qualified-name form\n   * suitable for `to_regclass(...)` arguments (e.g. `'\"public\".\"user\"'`).\n   * The unbound singleton overrides this to elide the schema prefix\n   * (`'\"user\"'`) so `search_path` resolves the object at runtime.\n   */\n  regclassLiteral(name: string): string {\n    return `'${escapeLiteral(this.qualifyTable(name))}'`;\n  }\n\n  /**\n   * Render a SQL expression that evaluates to this namespace's schema\n   * name at runtime, ready to drop into a `WHERE table_schema = …` /\n   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL\n   * literal (`'public'`); the unbound singleton overrides this to emit\n   * `current_schema()` so catalog queries match whichever schema the\n   * connection's `search_path` resolved at runtime.\n   */\n  schemaSqlExpression(): string {\n    return `'${escapeLiteral(this.id)}'`;\n  }\n\n  /**\n   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a\n   * builder-built catalog check compares `n.nspname` / `table_schema`\n   * against. Named schemas bind the schema name as a text parameter; the\n   * unbound singleton overrides this to the opaque `current_schema()`\n   * expression so the live connection's `search_path` decides at runtime.\n   */\n  schemaFilterExpression(): CfExpr {\n    return cfExpr.param(this.id, PG_TEXT_CODEC_ID);\n  }\n\n  /**\n   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a\n   * builder-built check uses to address a user table in this namespace.\n   * Named schemas qualify (`\"schema\".\"table\"`); the unbound singleton\n   * overrides this to leave the table unqualified so `search_path`\n   * resolves it at runtime.\n   */\n  tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      schema: this.id,\n      ...ifDefined('alias', alias),\n    });\n  }\n\n  /**\n   * The bare schema name a DDL planner should target when emitting\n   * statements that need to identify this namespace in the live\n   * database (e.g. `CREATE TABLE \"<ddlSchemaName>\".\"<table>\" …`,\n   * catalog filters, planner conflict lookups). Named schemas resolve\n   * to their own id. The `PostgresUnboundSchema` singleton inherits\n   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch\n   * through `qualifyTableName` route through the polymorphic\n   * `PostgresUnboundSchema` overrides and produce unqualified\n   * (search-path-resolved) output automatically.\n   */\n  ddlSchemaName(_storage: SqlStorage): string {\n    return this.id;\n  }\n}\n\n/**\n * Singleton subclass for the reserved sentinel namespace id\n * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding\n * the connection's `search_path` resolves at runtime. Overrides\n * qualifier emission to elide the schema prefix; call sites that consume\n * `qualifier()` / `qualifyTable()` get unqualified output without\n * branching on the namespace id.\n *\n * This is the target-side materialization of \"the framework provides\n * affordances; targets implement specifics\": the framework names the\n * sentinel; Postgres decides what late-bound means here (the table\n * name, naked — the schema is supplied by the live connection's\n * `search_path`).\n *\n * `ddlSchemaName` is inherited from `PostgresSchema` and returns\n * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`\n * route through the polymorphic factory and produce unqualified output\n * automatically.\n */\nexport class PostgresUnboundSchema extends PostgresSchema {\n  static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();\n\n  constructor(input?: PostgresSchemaInput) {\n    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });\n  }\n\n  override qualifier(): string {\n    return '';\n  }\n\n  override qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n\n  override schemaSqlExpression(): string {\n    return 'current_schema()';\n  }\n\n  override schemaFilterExpression(): CfExpr {\n    return cfExpr.raw('current_schema()', { codecId: PG_TEXT_CODEC_ID, nullable: false });\n  }\n\n  override tableSource(tableName: string, alias?: string): PostgresTableSource {\n    return new PostgresTableSource({\n      name: tableName,\n      ...ifDefined('alias', alias),\n    });\n  }\n}\n\nPostgresSchema.unbound = PostgresUnboundSchema.instance;\n\n/**\n * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`\n * so callers can dispatch to the polymorphic emission methods without\n * branching at the call site. Uses the structural `kind` discriminator\n * (`'schema'`) rather than `instanceof` so the check survives realm /\n * bundle / hot-reload boundaries — matching the rest of the IR's\n * narrowing convention. `PostgresUnboundSchema` passes through because\n * it inherits the same `kind: 'schema'` from `PostgresSchema`.\n */\nexport function isPostgresSchema(ns: unknown): ns is PostgresSchema {\n  return (ns as { kind?: unknown } | null | undefined)?.kind === 'schema';\n}\n\n/**\n * Target-supplied `Namespace` factory the Postgres target plumbs\n * through `defineContract({ createNamespace })` and the SQL PSL\n * interpreter. Returns the unbound singleton for the framework\n * sentinel and a fresh `PostgresSchema` for any other coordinate.\n *\n * The factory has no per-call state — every named id deterministically\n * maps to a distinct schema instance — so callers can pass it through\n * by reference and trust the resulting `SqlStorage.namespaces` map to\n * be value-stable for a given input set.\n */\nexport function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {\n  const schemaInput: PostgresSchemaInput = {\n    id: input.id,\n    entries: {\n      ...input.entries,\n      table: input.entries['table'] ?? {},\n    },\n  };\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(schemaInput);\n  }\n  return new PostgresSchema(schemaInput);\n}\n"],"mappings":"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"}

package/dist/postgres-schema-D0h4lsw2.d.mts

@@ -0,0 +1,158 @@
+import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy-D_z1osEq.mjs";
+import { t as PostgresRole } from "./postgres-role-_CCuyPCQ.mjs";
+import { NamespaceBase } from "@prisma-next/framework-components/ir";
+import { SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
+import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
+
+//#region src/core/postgres-schema.d.ts
+type PostgresNamespaceEntries = SqlNamespaceEntries & {
+  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
+  readonly role?: Readonly<Record<string, PostgresRole>>;
+};
+interface PostgresSchemaInput {
+  readonly id: string;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}
+/**
+ * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
+ * SCHEMA …`). Each Postgres `SqlStorage` carries a
+ * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
+ * the Postgres PSL interpreter from `namespace { … }` AST buckets.
+ *
+ * `entries` holds entity-kind maps (`table`, `valueSet`). 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.
+ * The unbound singleton below overrides these methods to elide the
+ * prefix entirely — call sites stay polymorphic and never branch on
+ * `id === UNBOUND_NAMESPACE_ID`.
+ */
+declare class PostgresSchema extends NamespaceBase {
+  /**
+   * Stable singleton reference for the late-bound slot. Materialised
+   * lazily below the singleton subclass declaration so the static
+   * initialiser sees the subclass before assigning. Consumers always
+   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`
+   * — same identity).
+   */
+  static unbound: PostgresUnboundSchema;
+  readonly kind: 'schema';
+  readonly id: string;
+  readonly entries: PostgresNamespaceEntries;
+  constructor(input: PostgresSchemaInput);
+  get table(): Readonly<Record<string, StorageTable>>;
+  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
+  get policy(): Readonly<Record<string, PostgresRlsPolicy>>;
+  get role(): Readonly<Record<string, PostgresRole>>;
+  /**
+   * The bare schema qualifier as it would appear in a rendered SQL
+   * fragment (already quoted). The unbound-schema singleton overrides
+   * this to return `''`.
+   */
+  qualifier(): string;
+  /**
+   * Qualify a table name with the schema prefix
+   * (`"<schema>"."<table>"`). The unbound-schema singleton overrides
+   * this to emit just `"<table>"` so the resolved DDL is unqualified
+   * and `search_path` decides where the object lands at runtime.
+   */
+  qualifyTable(tableName: string): string;
+  /**
+   * Render a SQL string-literal containing the qualified-name form
+   * suitable for `to_regclass(...)` arguments (e.g. `'"public"."user"'`).
+   * The unbound singleton overrides this to elide the schema prefix
+   * (`'"user"'`) so `search_path` resolves the object at runtime.
+   */
+  regclassLiteral(name: string): string;
+  /**
+   * Render a SQL expression that evaluates to this namespace's schema
+   * name at runtime, ready to drop into a `WHERE table_schema = …` /
+   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL
+   * literal (`'public'`); the unbound singleton overrides this to emit
+   * `current_schema()` so catalog queries match whichever schema the
+   * connection's `search_path` resolved at runtime.
+   */
+  schemaSqlExpression(): string;
+  /**
+   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+   * builder-built catalog check compares `n.nspname` / `table_schema`
+   * against. Named schemas bind the schema name as a text parameter; the
+   * unbound singleton overrides this to the opaque `current_schema()`
+   * expression so the live connection's `search_path` decides at runtime.
+   */
+  schemaFilterExpression(): CfExpr;
+  /**
+   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+   * builder-built check uses to address a user table in this namespace.
+   * Named schemas qualify (`"schema"."table"`); the unbound singleton
+   * overrides this to leave the table unqualified so `search_path`
+   * resolves it at runtime.
+   */
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
+  /**
+   * The bare schema name a DDL planner should target when emitting
+   * statements that need to identify this namespace in the live
+   * database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
+   * catalog filters, planner conflict lookups). Named schemas resolve
+   * to their own id. The `PostgresUnboundSchema` singleton inherits
+   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
+   * through `qualifyTableName` route through the polymorphic
+   * `PostgresUnboundSchema` overrides and produce unqualified
+   * (search-path-resolved) output automatically.
+   */
+  ddlSchemaName(_storage: SqlStorage): string;
+}
+/**
+ * Singleton subclass for the reserved sentinel namespace id
+ * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding
+ * the connection's `search_path` resolves at runtime. Overrides
+ * qualifier emission to elide the schema prefix; call sites that consume
+ * `qualifier()` / `qualifyTable()` get unqualified output without
+ * branching on the namespace id.
+ *
+ * This is the target-side materialization of "the framework provides
+ * affordances; targets implement specifics": the framework names the
+ * sentinel; Postgres decides what late-bound means here (the table
+ * name, naked — the schema is supplied by the live connection's
+ * `search_path`).
+ *
+ * `ddlSchemaName` is inherited from `PostgresSchema` and returns
+ * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+ * route through the polymorphic factory and produce unqualified output
+ * automatically.
+ */
+declare class PostgresUnboundSchema extends PostgresSchema {
+  static readonly instance: PostgresUnboundSchema;
+  constructor(input?: PostgresSchemaInput);
+  qualifier(): string;
+  qualifyTable(tableName: string): string;
+  schemaSqlExpression(): string;
+  schemaFilterExpression(): CfExpr;
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
+}
+/**
+ * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`
+ * so callers can dispatch to the polymorphic emission methods without
+ * branching at the call site. Uses the structural `kind` discriminator
+ * (`'schema'`) rather than `instanceof` so the check survives realm /
+ * bundle / hot-reload boundaries — matching the rest of the IR's
+ * narrowing convention. `PostgresUnboundSchema` passes through because
+ * it inherits the same `kind: 'schema'` from `PostgresSchema`.
+ */
+declare function isPostgresSchema(ns: unknown): ns is PostgresSchema;
+/**
+ * Target-supplied `Namespace` factory the Postgres target plumbs
+ * through `defineContract({ createNamespace })` and the SQL PSL
+ * interpreter. Returns the unbound singleton for the framework
+ * sentinel and a fresh `PostgresSchema` for any other coordinate.
+ *
+ * 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.
+ */
+declare function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema;
+//#endregion
+export { postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
+//# sourceMappingURL=postgres-schema-D0h4lsw2.d.mts.map

package/dist/postgres-schema-D0h4lsw2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-D0h4lsw2.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;;;;KAwBY,wBAAA,GAA2B,mBAAA;EAAA,SAC5B,MAAA,GAAS,QAAA,CAAS,MAAA,SAAe,iBAAA;EAAA,SACjC,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;AAAA;AAAA,UAGzB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;;;;cAiBxC,cAAA,SAAuB,aAAA;EAtBkB;AAAA;AAGtD;;;;;EAHsD,OA8B7C,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,wBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IAgCf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EAAA,IAIpC,MAAA,IAAU,QAAA,CAAS,MAAA,SAAe,iBAAA;EAAA,IAIlC,IAAA,IAAQ,QAAA,CAAS,MAAA,SAAe,YAAA;EA3Ee;;AAAM;AAiB3D;;EAmEE,SAAA;EA3DgB;;;;;;EAqEhB,YAAA,CAAa,SAAA;EA3BY;;;;;;EAqCzB,eAAA,CAAgB,IAAA;EA7BJ;;;;;;;;EAyCZ,mBAAA;EA3FgB;;;;;;;EAsGhB,sBAAA,IAA0B,MAAA;EAhEtB;;;;;;;EA2EJ,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;EAnE5C;;;;;;;;;;;EAsFJ,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;EAIA,sBAAA,IAA0B,MAAA;EAI1B,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;AAAA;;;;;;;;;;iBAmB3C,gBAAA,CAAiB,EAAA,YAAc,EAAA,IAAM,cAAc;;AAnBW;AAmB9E;;;;;;;;AAAmE;iBAenD,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}

package/dist/postgres-schema-ir-BF0X8jit.mjs

@@ -0,0 +1,66 @@
+import { freezeNode } from "@prisma-next/framework-components/ir";
+import { SqlSchemaIRNode, SqlTableIR } from "@prisma-next/sql-schema-ir/types";
+//#region src/core/postgres-schema-ir.ts
+/**
+* Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`
+* (same `tables` + optional `annotations` fields) and adds typed fields for
+* data the postgres adapter collects during introspection.
+*
+* Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because
+* `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents
+* subclass field initialisation. `PostgresSchemaIR` replicates the minimal
+* `SqlSchemaIR` structure and freezes itself at the end of its own
+* constructor.
+*
+* RLS-specific fields (`rlsPolicies`, `roles`) are typed top-level fields on
+* this class — no `Reflect.get`, no untyped annotation bag access. The
+* `annotations.pg` bag is populated with only the subset the family layer
+* reads (`nativeEnumTypeNames`, `existingSchemas`, `schema`) so family-layer
+* PSL inference and namespace verification continue to work without knowing
+* about RLS.
+*
+* Nothing RLS-specific leaks into the sql-family layer.
+*/
+var PostgresSchemaIR = class extends SqlSchemaIRNode {
+	nodeTarget = "postgres";
+	tables;
+	pgSchemaName;
+	pgVersion;
+	rlsPolicies;
+	roles;
+	existingSchemas;
+	nativeEnumTypeNames;
+	constructor(input) {
+		super();
+		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables).map(([key, t]) => [key, t instanceof SqlTableIR ? t : new SqlTableIR(t)])));
+		this.pgSchemaName = input.pgSchemaName;
+		this.pgVersion = input.pgVersion;
+		this.rlsPolicies = Object.freeze([...input.rlsPolicies]);
+		this.roles = Object.freeze([...input.roles]);
+		this.existingSchemas = Object.freeze([...input.existingSchemas]);
+		this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
+		this.annotations = { pg: {
+			schema: input.pgSchemaName,
+			...input.nativeEnumTypeNames.length > 0 && { nativeEnumTypeNames: input.nativeEnumTypeNames },
+			...input.existingSchemas.length > 0 && { existingSchemas: input.existingSchemas }
+		} };
+		freezeNode(this);
+	}
+};
+/**
+* Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`
+* discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field
+* (a plain class-field initializer), so it survives the `{ ...schema, tables }`
+* spread the multi-space verify path (`projectSchemaToSpace`) produces — that
+* projected object is not a class instance but retains every enumerable own
+* property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable
+* here: it is shared by every SQL schema-IR node and is non-enumerable (dropped
+* by the spread).
+*/
+function isPostgresSchemaIR(schema) {
+	return schema.nodeTarget === "postgres";
+}
+//#endregion
+export { isPostgresSchemaIR as n, PostgresSchemaIR as t };
+
+//# sourceMappingURL=postgres-schema-ir-BF0X8jit.mjs.map

package/dist/postgres-schema-ir-BF0X8jit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-BF0X8jit.mjs","names":[],"sources":["../src/core/postgres-schema-ir.ts"],"sourcesContent":["import { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  type SqlAnnotations,\n  type SqlSchemaIR,\n  SqlSchemaIRNode,\n  type SqlSchemaTarget,\n  SqlTableIR,\n  type SqlTableIRInput,\n} from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './postgres-role';\n\nexport interface PostgresSchemaIRInput {\n  readonly tables: Record<string, SqlTableIR | SqlTableIRInput>;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\n  readonly rlsPolicies: readonly PostgresRlsPolicy[];\n  readonly roles: readonly PostgresRole[];\n  readonly existingSchemas: readonly string[];\n  readonly nativeEnumTypeNames: readonly string[];\n}\n\n/**\n * Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`\n * (same `tables` + optional `annotations` fields) and adds typed fields for\n * data the postgres adapter collects during introspection.\n *\n * Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because\n * `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents\n * subclass field initialisation. `PostgresSchemaIR` replicates the minimal\n * `SqlSchemaIR` structure and freezes itself at the end of its own\n * constructor.\n *\n * RLS-specific fields (`rlsPolicies`, `roles`) are typed top-level fields on\n * this class — no `Reflect.get`, no untyped annotation bag access. The\n * `annotations.pg` bag is populated with only the subset the family layer\n * reads (`nativeEnumTypeNames`, `existingSchemas`, `schema`) so family-layer\n * PSL inference and namespace verification continue to work without knowing\n * about RLS.\n *\n * Nothing RLS-specific leaks into the sql-family layer.\n */\nexport class PostgresSchemaIR extends SqlSchemaIRNode {\n  readonly nodeTarget: SqlSchemaTarget = 'postgres';\n  readonly tables: Readonly<Record<string, SqlTableIR>>;\n  declare readonly annotations?: SqlAnnotations;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\n  readonly rlsPolicies: readonly PostgresRlsPolicy[];\n  readonly roles: readonly PostgresRole[];\n  readonly existingSchemas: readonly string[];\n  readonly nativeEnumTypeNames: readonly string[];\n\n  constructor(input: PostgresSchemaIRInput) {\n    super();\n    this.tables = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.tables).map(([key, t]) => [\n          key,\n          t instanceof SqlTableIR ? t : new SqlTableIR(t),\n        ]),\n      ),\n    );\n    this.pgSchemaName = input.pgSchemaName;\n    this.pgVersion = input.pgVersion;\n    this.rlsPolicies = Object.freeze([...input.rlsPolicies]);\n    this.roles = Object.freeze([...input.roles]);\n    this.existingSchemas = Object.freeze([...input.existingSchemas]);\n    this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);\n    // Populate the annotations.pg bag with only the subset the family layer\n    // reads (nativeEnumTypeNames for PSL inference, existingSchemas for\n    // namespace presence checks). rlsPolicies and roles are NOT placed here\n    // — they are consumed directly via typed fields on this class.\n    this.annotations = {\n      pg: {\n        schema: input.pgSchemaName,\n        ...(input.nativeEnumTypeNames.length > 0 && {\n          nativeEnumTypeNames: input.nativeEnumTypeNames,\n        }),\n        ...(input.existingSchemas.length > 0 && {\n          existingSchemas: input.existingSchemas,\n        }),\n      },\n    };\n    freezeNode(this);\n  }\n}\n\n/**\n * Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`\n * discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field\n * (a plain class-field initializer), so it survives the `{ ...schema, tables }`\n * spread the multi-space verify path (`projectSchemaToSpace`) produces — that\n * projected object is not a class instance but retains every enumerable own\n * property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable\n * here: it is shared by every SQL schema-IR node and is non-enumerable (dropped\n * by the spread).\n */\nexport function isPostgresSchemaIR(schema: SqlSchemaIR): schema is PostgresSchemaIR {\n  return schema.nodeTarget === 'postgres';\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,mBAAb,cAAsC,gBAAgB;CACpD,aAAuC;CACvC;CAEA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,OAA8B;EACxC,MAAM;EACN,KAAK,SAAS,OAAO,OACnB,OAAO,YACL,OAAO,QAAQ,MAAM,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,OAAO,CAC7C,KACA,aAAa,aAAa,IAAI,IAAI,WAAW,CAAC,CAChD,CAAC,CACH,CACF;EACA,KAAK,eAAe,MAAM;EAC1B,KAAK,YAAY,MAAM;EACvB,KAAK,cAAc,OAAO,OAAO,CAAC,GAAG,MAAM,WAAW,CAAC;EACvD,KAAK,QAAQ,OAAO,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC;EAC3C,KAAK,kBAAkB,OAAO,OAAO,CAAC,GAAG,MAAM,eAAe,CAAC;EAC/D,KAAK,sBAAsB,OAAO,OAAO,CAAC,GAAG,MAAM,mBAAmB,CAAC;EAKvE,KAAK,cAAc,EACjB,IAAI;GACF,QAAQ,MAAM;GACd,GAAI,MAAM,oBAAoB,SAAS,KAAK,EAC1C,qBAAqB,MAAM,oBAC7B;GACA,GAAI,MAAM,gBAAgB,SAAS,KAAK,EACtC,iBAAiB,MAAM,gBACzB;EACF,EACF;EACA,WAAW,IAAI;CACjB;AACF;;;;;;;;;;;AAYA,SAAgB,mBAAmB,QAAiD;CAClF,OAAO,OAAO,eAAe;AAC/B"}

package/dist/postgres-schema-ir-BQ3RpZMz.d.mts

@@ -0,0 +1,60 @@
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy-D_z1osEq.mjs";
+import { t as PostgresRole } from "./postgres-role-_CCuyPCQ.mjs";
+import { SqlAnnotations, SqlSchemaIR, SqlSchemaIRNode, SqlSchemaTarget, SqlTableIR, SqlTableIRInput } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/postgres-schema-ir.d.ts
+interface PostgresSchemaIRInput {
+  readonly tables: Record<string, SqlTableIR | SqlTableIRInput>;
+  readonly pgSchemaName: string;
+  readonly pgVersion: string;
+  readonly rlsPolicies: readonly PostgresRlsPolicy[];
+  readonly roles: readonly PostgresRole[];
+  readonly existingSchemas: readonly string[];
+  readonly nativeEnumTypeNames: readonly string[];
+}
+/**
+ * Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`
+ * (same `tables` + optional `annotations` fields) and adds typed fields for
+ * data the postgres adapter collects during introspection.
+ *
+ * Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because
+ * `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents
+ * subclass field initialisation. `PostgresSchemaIR` replicates the minimal
+ * `SqlSchemaIR` structure and freezes itself at the end of its own
+ * constructor.
+ *
+ * RLS-specific fields (`rlsPolicies`, `roles`) are typed top-level fields on
+ * this class — no `Reflect.get`, no untyped annotation bag access. The
+ * `annotations.pg` bag is populated with only the subset the family layer
+ * reads (`nativeEnumTypeNames`, `existingSchemas`, `schema`) so family-layer
+ * PSL inference and namespace verification continue to work without knowing
+ * about RLS.
+ *
+ * Nothing RLS-specific leaks into the sql-family layer.
+ */
+declare class PostgresSchemaIR extends SqlSchemaIRNode {
+  readonly nodeTarget: SqlSchemaTarget;
+  readonly tables: Readonly<Record<string, SqlTableIR>>;
+  readonly annotations?: SqlAnnotations;
+  readonly pgSchemaName: string;
+  readonly pgVersion: string;
+  readonly rlsPolicies: readonly PostgresRlsPolicy[];
+  readonly roles: readonly PostgresRole[];
+  readonly existingSchemas: readonly string[];
+  readonly nativeEnumTypeNames: readonly string[];
+  constructor(input: PostgresSchemaIRInput);
+}
+/**
+ * Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`
+ * discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field
+ * (a plain class-field initializer), so it survives the `{ ...schema, tables }`
+ * spread the multi-space verify path (`projectSchemaToSpace`) produces — that
+ * projected object is not a class instance but retains every enumerable own
+ * property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable
+ * here: it is shared by every SQL schema-IR node and is non-enumerable (dropped
+ * by the spread).
+ */
+declare function isPostgresSchemaIR(schema: SqlSchemaIR): schema is PostgresSchemaIR;
+//#endregion
+export { PostgresSchemaIRInput as n, isPostgresSchemaIR as r, PostgresSchemaIR as t };
+//# sourceMappingURL=postgres-schema-ir-BQ3RpZMz.d.mts.map

package/dist/postgres-schema-ir-BQ3RpZMz.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-BQ3RpZMz.d.mts","names":[],"sources":["../src/core/postgres-schema-ir.ts"],"mappings":";;;;;UAYiB,qBAAA;EAAA,SACN,MAAA,EAAQ,MAAA,SAAe,UAAA,GAAa,eAAA;EAAA,SACpC,YAAA;EAAA,SACA,SAAA;EAAA,SACA,WAAA,WAAsB,iBAAA;EAAA,SACtB,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;AAAA;;;;;;;;;;;;;;;;;AAAmB;AAuB9B;;;cAAa,gBAAA,SAAyB,eAAA;EAAA,SAC3B,UAAA,EAAY,eAAA;EAAA,SACZ,MAAA,EAAQ,QAAA,CAAS,MAAA,SAAe,UAAA;EAAA,SACxB,WAAA,GAAc,cAAA;EAAA,SACtB,YAAA;EAAA,SACA,SAAA;EAAA,SACA,WAAA,WAAsB,iBAAA;EAAA,SACtB,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;cAEG,KAAA,EAAO,qBAAA;AAAA;;;;;;;;;;;iBA6CL,kBAAA,CAAmB,MAAA,EAAQ,WAAA,GAAc,MAAA,IAAU,gBAAgB"}

package/dist/postgres-schema-ir-annotations-El62Sywa.mjs

@@ -0,0 +1,14 @@
+import { r as isPostgresSchema } from "./postgres-schema-BVDr_61a.mjs";
+import { n as isPostgresSchemaIR } from "./postgres-schema-ir-BF0X8jit.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+//#region src/core/postgres-schema-ir-annotations.ts
+function resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schemaIr) {
+	if (namespaceId === UNBOUND_NAMESPACE_ID) return (schemaIr && isPostgresSchemaIR(schemaIr) ? schemaIr.pgSchemaName : void 0) ?? "public";
+	const namespace = storage.namespaces[namespaceId];
+	if (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
+	return namespaceId;
+}
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage as t };
+
+//# sourceMappingURL=postgres-schema-ir-annotations-El62Sywa.mjs.map

package/dist/postgres-schema-ir-annotations-El62Sywa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-annotations-El62Sywa.mjs","names":[],"sources":["../src/core/postgres-schema-ir-annotations.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { isPostgresSchema } from './postgres-schema';\nimport { isPostgresSchemaIR } from './postgres-schema-ir';\n\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n  schemaIr?: SqlSchemaIR,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return (\n      (schemaIr && isPostgresSchemaIR(schemaIr) ? schemaIr.pgSchemaName : undefined) ?? 'public'\n    );\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;AAMA,SAAgB,oCACd,SACA,aACA,UACQ;CACR,IAAI,gBAAgB,sBAClB,QACG,YAAY,mBAAmB,QAAQ,IAAI,SAAS,eAAe,KAAA,MAAc;CAGtF,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}

package/dist/render-ops.d.mts

@@ -1,4 +1,4 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIY6tLeo.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { OpFactoryCall } from "@prisma-next/framework-components/control";
 import { ExecuteRequestLowerer } from "@prisma-next/family-sql/control-adapter";

package/dist/rls-canonicalize.d.mts

@@ -0,0 +1,2 @@
+import { i as normalizePredicate, n as RlsPolicyOperation, r as computeContentHash, t as ContentHashParts } from "./canonicalize-CAbXtVtB.mjs";
+export { type ContentHashParts, type RlsPolicyOperation, computeContentHash, normalizePredicate };

package/dist/rls-canonicalize.mjs

@@ -0,0 +1,2 @@
+import { n as normalizePredicate, t as computeContentHash } from "./canonicalize-Bn3BM1Cn.mjs";
+export { computeContentHash, normalizePredicate };

package/dist/runtime.d.mts

@@ -1,5 +1,5 @@
 import { AnyCodecDescriptor } from "@prisma-next/framework-components/codec";
-import { Namespace } from "@prisma-next/framework-components/ir";
+import { AnyEntityKindDescriptor, Namespace } from "@prisma-next/framework-components/ir";
 import { SqlNamespaceTablesInput, SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { Contract } from "@prisma-next/contract/types";
@@ -8,11 +8,12 @@ import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/core/postgres-contract-serializer.d.ts
 declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
-  constructor();
+  constructor(extraPackEntityKinds?: readonly AnyEntityKindDescriptor[]);
   protected get defaultNamespaceId(): string;
   protected hydrateSqlNamespaceEntry(nsId: string, raw: Namespace | Record<string, unknown>): Namespace | SqlNamespaceTablesInput;
   serializeContract(contract: Contract<SqlStorage>): JsonObject;
   private serializePostgresNamespace;
+  private serializeJsonObject;
   private serializeJsonValue;
 }
 //#endregion

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cAkEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;;gBAM1D,kBAAA;EAAA,UAIJ,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EA0BN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QAuCpD,0BAAA;EAAA,QAyBA,kBAAA;AAAA;;;UChKO,6BAAA,SAAsC,qBAAqB;;;;;ADyD5E;;cCjDM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cAqEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;cACrE,oBAAA,YAA+B,uBAAA;EAAA,cAKpB,kBAAA;EAAA,UAIJ,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EA4BN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QA0CpD,0BAAA;EAAA,QAgCA,mBAAA;EAAA,QAOA,kBAAA;AAAA;;;UCtLO,6BAAA,SAAsC,qBAAqB;;;;;AD4D5E;;cCpDM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
-import { n as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-CpGygXpI.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-k3TAcPMY.mjs";
+import { n as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-b_SzXwen.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-k5eg5ZUZ.mjs";
 //#region src/exports/runtime.ts
 /**
 * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor` from `@prisma-next/sql-runtime`. The target package is a control-plane residence and must not pull the SQL execution-plane package into its dependency closure. The runtime descriptor here is shaped to satisfy the framework's `RuntimeTargetDescriptor` plus the structural `SqlStaticContributions` (`codecs:` returning a descriptor list) that

package/dist/schema-ir-annotations.d.mts

@@ -0,0 +1,8 @@
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/postgres-schema-ir-annotations.d.ts
+declare function resolveDdlSchemaForNamespaceStorage(storage: SqlStorage, namespaceId: string, schemaIr?: SqlSchemaIR): string;
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage };
+//# sourceMappingURL=schema-ir-annotations.d.mts.map

package/dist/schema-ir-annotations.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-ir-annotations.d.mts","names":[],"sources":["../src/core/postgres-schema-ir-annotations.ts"],"mappings":";;;;iBAMgB,mCAAA,CACd,OAAA,EAAS,UAAA,EACT,WAAA,UACA,QAAA,GAAW,WAAW"}

package/dist/schema-ir-annotations.mjs

@@ -0,0 +1,2 @@
+import { t as resolveDdlSchemaForNamespaceStorage } from "./postgres-schema-ir-annotations-El62Sywa.mjs";
+export { resolveDdlSchemaForNamespaceStorage };

package/dist/types.d.mts

@@ -1,141 +1,6 @@
-import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
+import { n as PostgresRlsPolicyInput, r as RlsPolicyOperation, t as PostgresRlsPolicy } from "./postgres-rls-policy-D_z1osEq.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
-import { NamespaceBase } from "@prisma-next/framework-components/ir";
-import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
-import { SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
-
-//#region src/core/postgres-schema.d.ts
-interface PostgresSchemaInput {
-  readonly id: string;
-  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-}
-/**
- * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
- * SCHEMA …`). Each Postgres `SqlStorage` carries a
- * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
- * the Postgres PSL interpreter from `namespace { … }` AST buckets.
- *
- * `entries` holds entity-kind maps (`table`, `valueSet`). 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.
- * The unbound singleton below overrides these methods to elide the
- * prefix entirely — call sites stay polymorphic and never branch on
- * `id === UNBOUND_NAMESPACE_ID`.
- */
-declare class PostgresSchema extends NamespaceBase {
-  /**
-   * Stable singleton reference for the late-bound slot. Materialised
-   * lazily below the singleton subclass declaration so the static
-   * initialiser sees the subclass before assigning. Consumers always
-   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`
-   * — same identity).
-   */
-  static unbound: PostgresUnboundSchema;
-  readonly kind: 'schema';
-  readonly id: string;
-  readonly entries: SqlNamespaceEntries;
-  constructor(input: PostgresSchemaInput);
-  get table(): Readonly<Record<string, StorageTable>>;
-  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
-   * this to return `''`.
-   */
-  qualifier(): string;
-  /**
-   * Qualify a table name with the schema prefix
-   * (`"<schema>"."<table>"`). The unbound-schema singleton overrides
-   * this to emit just `"<table>"` so the resolved DDL is unqualified
-   * and `search_path` decides where the object lands at runtime.
-   */
-  qualifyTable(tableName: string): string;
-  /**
-   * Render a SQL string-literal containing the qualified-name form
-   * suitable for `to_regclass(...)` arguments (e.g. `'"public"."user"'`).
-   * The unbound singleton overrides this to elide the schema prefix
-   * (`'"user"'`) so `search_path` resolves the object at runtime.
-   */
-  regclassLiteral(name: string): string;
-  /**
-   * Render a SQL expression that evaluates to this namespace's schema
-   * name at runtime, ready to drop into a `WHERE table_schema = …` /
-   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL
-   * literal (`'public'`); the unbound singleton overrides this to emit
-   * `current_schema()` so catalog queries match whichever schema the
-   * connection's `search_path` resolved at runtime.
-   */
-  schemaSqlExpression(): string;
-  /**
-   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
-   * builder-built catalog check compares `n.nspname` / `table_schema`
-   * against. Named schemas bind the schema name as a text parameter; the
-   * unbound singleton overrides this to the opaque `current_schema()`
-   * expression so the live connection's `search_path` decides at runtime.
-   */
-  schemaFilterExpression(): CfExpr;
-  /**
-   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
-   * builder-built check uses to address a user table in this namespace.
-   * Named schemas qualify (`"schema"."table"`); the unbound singleton
-   * overrides this to leave the table unqualified so `search_path`
-   * resolves it at runtime.
-   */
-  tableSource(tableName: string, alias?: string): PostgresTableSource;
-  /**
-   * The bare schema name a DDL planner should target when emitting
-   * statements that need to identify this namespace in the live
-   * database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
-   * catalog filters, planner conflict lookups). Named schemas resolve
-   * to their own id. The `PostgresUnboundSchema` singleton inherits
-   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
-   * through `qualifyTableName` route through the polymorphic
-   * `PostgresUnboundSchema` overrides and produce unqualified
-   * (search-path-resolved) output automatically.
-   */
-  ddlSchemaName(_storage: SqlStorage): string;
-}
-/**
- * Singleton subclass for the reserved sentinel namespace id
- * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding
- * the connection's `search_path` resolves at runtime. Overrides
- * qualifier emission to elide the schema prefix; call sites that consume
- * `qualifier()` / `qualifyTable()` get unqualified output without
- * branching on the namespace id.
- *
- * This is the target-side materialization of "the framework provides
- * affordances; targets implement specifics": the framework names the
- * sentinel; Postgres decides what late-bound means here (the table
- * name, naked — the schema is supplied by the live connection's
- * `search_path`).
- *
- * `ddlSchemaName` is inherited from `PostgresSchema` and returns
- * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
- * route through the polymorphic factory and produce unqualified output
- * automatically.
- */
-declare class PostgresUnboundSchema extends PostgresSchema {
-  static readonly instance: PostgresUnboundSchema;
-  constructor(input?: PostgresSchemaInput);
-  qualifier(): string;
-  qualifyTable(tableName: string): string;
-  schemaSqlExpression(): string;
-  schemaFilterExpression(): CfExpr;
-  tableSource(tableName: string, alias?: string): PostgresTableSource;
-}
-/**
- * Target-supplied `Namespace` factory the Postgres target plumbs
- * through `defineContract({ createNamespace })` and the SQL PSL
- * interpreter. Returns the unbound singleton for the framework
- * sentinel and a fresh `PostgresSchema` for any other coordinate.
- *
- * 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.
- */
-declare function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema;
-//#endregion
-export { type PostgresColumnDefault, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
-//# sourceMappingURL=types.d.mts.map
+import { n as PostgresRoleInput, t as PostgresRole } from "./postgres-role-_CCuyPCQ.mjs";
+import { i as postgresCreateNamespace, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-D0h4lsw2.mjs";
+import { n as PostgresSchemaIRInput, r as isPostgresSchemaIR, t as PostgresSchemaIR } from "./postgres-schema-ir-BQ3RpZMz.mjs";
+export { type PostgresColumnDefault, PostgresRlsPolicy, type PostgresRlsPolicyInput, PostgresRole, type PostgresRoleInput, PostgresSchema, PostgresSchemaIR, type PostgresSchemaIRInput, PostgresUnboundSchema, type RlsPolicyOperation, isPostgresSchema, isPostgresSchemaIR, postgresCreateNamespace };

package/dist/types.mjs

@@ -1,2 +1,3 @@
-import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-COGZ1ark.mjs";
-export { PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
+import { d as PostgresRlsPolicy, i as postgresCreateNamespace, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema, u as PostgresRole } from "./postgres-schema-BVDr_61a.mjs";
+import { n as isPostgresSchemaIR, t as PostgresSchemaIR } from "./postgres-schema-ir-BF0X8jit.mjs";
+export { PostgresRlsPolicy, PostgresRole, PostgresSchema, PostgresSchemaIR, PostgresUnboundSchema, isPostgresSchema, isPostgresSchemaIR, postgresCreateNamespace };