@prisma-next/target-postgres 0.14.0-dev.3 → 0.14.0-dev.31

package/dist/{postgres-schema-COGZ1ark.mjs → postgres-schema-DLcc3W2-.mjs}

@@ -2,10 +2,125 @@ import { _ as PG_TEXT_CODEC_ID } from "./codec-ids-BvytN2P8.mjs";
 import { n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
 import { TableSource } from "@prisma-next/sql-relational-core/ast";
 import { blindCast } from "@prisma-next/utils/casts";
+import { type } from "arktype";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
+import { UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
+import { SqlNamespaceBase, SqlNode } from "@prisma-next/sql-contract/types";
 import { composeSqlEntityKinds } from "@prisma-next/sql-contract/entity-kinds";
 import { cfExpr } from "@prisma-next/sql-relational-core/contract-free";
+//#region src/core/postgres-validators.ts
+const PostgresRoleSchema = type({
+	kind: "'role'",
+	name: "string",
+	namespaceId: "string"
+});
+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"
+});
+//#endregion
+//#region src/core/schema-ir/postgres-rls-policy.ts
+/**
+* Postgres IR class for a row-level security policy (`CREATE POLICY … ON …`).
+*
+* 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).
+*/
+var PostgresRlsPolicy = class extends SqlNode {
+	kind = "policy";
+	name;
+	prefix;
+	tableName;
+	namespaceId;
+	operation;
+	roles;
+	permissive;
+	constructor(input) {
+		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 !== void 0) this.using = input.using;
+		if (input.withCheck !== void 0) this.withCheck = input.withCheck;
+		this.permissive = input.permissive;
+		freezeNode(this);
+	}
+	get id() {
+		return this.name;
+	}
+	children() {
+		return [];
+	}
+	/**
+	* Equality by wire name only. The wire name is `<prefix>_<sha256(body)[0..8]>`,
+	* so name-equality IS body-equality — two policies with different bodies
+	* have different hashes and therefore different names. We deliberately
+	* skip comparing bodies directly because Postgres reprints predicate
+	* expressions (e.g. strips outer parentheses), so a byte-compare against
+	* the authored body would produce false mismatches on a clean re-verify.
+	*/
+	isEqualTo(other) {
+		if (!isPostgresRlsPolicy(other)) throw new Error(`PostgresRlsPolicy.isEqualTo: expected a PostgresRlsPolicy, got ${other.constructor?.name ?? typeof other}`);
+		return this.name === other.name;
+	}
+};
+function isPostgresRlsPolicy(node) {
+	return node !== void 0 && "kind" in node && node.kind === "policy";
+}
+function assertPostgresRlsPolicy(node) {
+	if (!isPostgresRlsPolicy(node)) {
+		const kind = node !== void 0 && "kind" in node ? String(node.kind) : typeof node;
+		throw new Error(`planPostgresSchemaDiff: expected a PostgresRlsPolicy on the policy-diff path but got ${kind}`);
+	}
+}
+//#endregion
+//#region src/core/schema-ir/postgres-role.ts
+/**
+* Postgres IR class for a database role (`CREATE 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).
+*/
+var PostgresRole = class PostgresRole extends SqlNode {
+	kind = "role";
+	name;
+	namespaceId;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.namespaceId = input.namespaceId;
+		freezeNode(this);
+	}
+	/** Roles are cluster-unique; the name alone is sufficient as the id. */
+	get id() {
+		return this.name;
+	}
+	children() {
+		return [];
+	}
+	isEqualTo(other) {
+		if (!(other instanceof PostgresRole)) throw new Error(`PostgresRole.isEqualTo: expected a PostgresRole, got ${other.constructor?.name ?? typeof other}`);
+		return this.name === other.name;
+	}
+};
+//#endregion
 //#region src/core/ast/table-source.ts
 var PostgresTableSource = class extends TableSource {
 	schema;
@@ -19,6 +134,18 @@ var PostgresTableSource = class extends TableSource {
 	}
 };
 //#endregion
+//#region src/core/entity-kinds.ts
+const policyEntityKind = {
+	kind: "policy",
+	schema: PostgresRlsPolicySchema,
+	construct: (input) => new PostgresRlsPolicy(input)
+};
+const roleEntityKind = {
+	kind: "role",
+	schema: PostgresRoleSchema,
+	construct: (input) => new PostgresRole(input)
+};
+//#endregion
 //#region src/core/postgres-schema.ts
 /**
 * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
@@ -34,7 +161,7 @@ var PostgresTableSource = class extends TableSource {
 * prefix entirely — call sites stay polymorphic and never branch on
 * `id === UNBOUND_NAMESPACE_ID`.
 */
-var PostgresSchema = class extends NamespaceBase {
+var PostgresSchema = class extends SqlNamespaceBase {
 	/**
 	* Stable singleton reference for the late-bound slot. Materialised
 	* lazily below the singleton subclass declaration so the static
@@ -48,7 +175,7 @@ var PostgresSchema = class extends NamespaceBase {
 	constructor(input) {
 		super();
 		this.id = input.id;
-		const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), "carry");
+		const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds([policyEntityKind, roleEntityKind]), "carry");
 		const valueSetRaw = dispatched["valueSet"];
 		const withPresence = valueSetRaw !== void 0 && Object.keys(valueSetRaw).length === 0 ? {
 			...dispatched,
@@ -69,6 +196,12 @@ var PostgresSchema = class extends NamespaceBase {
 	get valueSet() {
 		return this.entries.valueSet;
 	}
+	get policy() {
+		return this.entries.policy ?? Object.freeze({});
+	}
+	get role() {
+		return this.entries.role ?? Object.freeze({});
+	}
 	/**
 	* The bare schema qualifier as it would appear in a rendered SQL
 	* fragment (already quoted). The unbound-schema singleton overrides
@@ -230,6 +363,6 @@ function postgresCreateNamespace(input) {
 	return new PostgresSchema(schemaInput);
 }
 //#endregion
-export { PostgresTableSource as a, postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
+export { policyEntityKind as a, PostgresRole as c, isPostgresRlsPolicy as d, PostgresRlsPolicySchema as f, postgresCreateNamespace as i, PostgresRlsPolicy as l, PostgresUnboundSchema as n, roleEntityKind as o, PostgresRoleSchema as p, isPostgresSchema as r, PostgresTableSource as s, PostgresSchema as t, assertPostgresRlsPolicy as u };
 
-//# sourceMappingURL=postgres-schema-COGZ1ark.mjs.map
+//# sourceMappingURL=postgres-schema-DLcc3W2-.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-DLcc3W2-.mjs","names":[],"sources":["../src/core/postgres-validators.ts","../src/core/schema-ir/postgres-rls-policy.ts","../src/core/schema-ir/postgres-role.ts","../src/core/ast/table-source.ts","../src/core/entity-kinds.ts","../src/core/postgres-schema.ts"],"sourcesContent":["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 type { DiffableNode } from '@prisma-next/framework-components/control';\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  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\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.constructor?.name ?? typeof other}`,\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      `planPostgresSchemaDiff: 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 { 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  /** Roles are cluster-unique; the name alone is sufficient as the id. */\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    if (!(other instanceof PostgresRole)) {\n      throw new Error(\n        `PostgresRole.isEqualTo: expected a PostgresRole, got ${other.constructor?.name ?? typeof other}`,\n      );\n    }\n    return this.name === other.name;\n  }\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 { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';\nimport { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './schema-ir/postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './schema-ir/postgres-role';\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 type { Contract } from '@prisma-next/contract/types';\nimport {\n  freezeNode,\n  hydrateNamespaceEntities,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { composeSqlEntityKinds } from '@prisma-next/sql-contract/entity-kinds';\nimport {\n  SqlNamespaceBase,\n  type SqlNamespaceEntries,\n  type SqlNamespaceInput,\n  type SqlStorage,\n  type StorageTable,\n  type StorageValueSet,\n} from '@prisma-next/sql-contract/types';\n\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 './schema-ir/postgres-rls-policy';\nimport type { PostgresRole } from './schema-ir/postgres-role';\nimport { escapeLiteral } from './sql-utils';\n\nexport type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };\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 SqlNamespaceBase {\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: SqlNamespaceInput): 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-ir-BJl_a3J7.d.mts

@@ -0,0 +1,102 @@
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy-12wAEQhs.mjs";
+import { o as PostgresRole } from "./postgres-schema-DJUEkWg-.mjs";
+import { PrimaryKey, SqlAnnotations, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlSchemaIRNode, SqlSchemaTarget, SqlTableIRInput, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+import { DiffableNode } from "@prisma-next/framework-components/control";
+
+//#region src/core/schema-ir/postgres-table-ir.d.ts
+interface PostgresTableIRInput extends SqlTableIRInput {
+  readonly rlsPolicies?: readonly PostgresRlsPolicy[];
+}
+/**
+ * Postgres-specific table IR node. Carries all `SqlTableIR` fields plus
+ * `rlsPolicies`, and implements `DiffableNode` so the table instance is
+ * directly the diff-tree node — no separate wrapper needed.
+ *
+ * Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because
+ * `SqlTableIR` calls `freezeNode` in its own constructor, which prevents
+ * subclass field initialisation. Same pattern as `PostgresSchemaIR`.
+ *
+ * `id` is the table name. `children()` returns the policies on this table.
+ * `isEqualTo` is always true — table-level attributes are not diffed yet.
+ */
+declare class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {
+  readonly name: string;
+  readonly columns: Readonly<Record<string, SqlColumnIR>>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR>;
+  readonly indexes: ReadonlyArray<SqlIndexIR>;
+  readonly primaryKey?: PrimaryKey;
+  readonly annotations?: SqlAnnotations;
+  readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;
+  readonly rlsPolicies: readonly PostgresRlsPolicy[];
+  constructor(input: PostgresTableIRInput);
+  get id(): string;
+  isEqualTo(_other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+}
+declare function isPostgresTableIR(node: DiffableNode): node is PostgresTableIR;
+//#endregion
+//#region src/core/schema-ir/postgres-schema-ir.d.ts
+interface PostgresSchemaIRInput {
+  readonly tables: Record<string, PostgresTableIR | (SqlTableIRInput & {
+    rlsPolicies?: readonly PostgresRlsPolicy[];
+  })>;
+  readonly pgSchemaName: string;
+  readonly pgVersion: string;
+  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.
+ *
+ * `tables` holds `PostgresTableIR` instances which carry their own RLS
+ * policies. `children()` returns the tables directly — the table instances
+ * ARE the diff-tree nodes.
+ *
+ * Nothing RLS-specific leaks into the sql-family layer.
+ */
+declare class PostgresSchemaIR extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeTarget: SqlSchemaTarget;
+  readonly tables: Readonly<Record<string, PostgresTableIR>>;
+  readonly annotations?: SqlAnnotations;
+  readonly pgSchemaName: string;
+  readonly pgVersion: string;
+  readonly roles: readonly PostgresRole[];
+  readonly existingSchemas: readonly string[];
+  readonly nativeEnumTypeNames: readonly string[];
+  constructor(input: PostgresSchemaIRInput);
+  get id(): string;
+  get rlsPolicies(): readonly PostgresRlsPolicy[];
+  isEqualTo(_other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+}
+/**
+ * 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;
+declare function assertPostgresSchemaIR(schema: SqlSchemaIR): asserts schema is PostgresSchemaIR;
+/**
+ * Returns `schema` as-is when it is a real `PostgresSchemaIR` instance, or
+ * reconstructs one when `projectSchemaToSpace` has spread the class into a
+ * plain object (losing prototype methods).
+ */
+declare function ensurePostgresSchemaIR(schema: PostgresSchemaIR): PostgresSchemaIR;
+//#endregion
+export { isPostgresSchemaIR as a, isPostgresTableIR as c, ensurePostgresSchemaIR as i, PostgresSchemaIRInput as n, PostgresTableIR as o, assertPostgresSchemaIR as r, PostgresTableIRInput as s, PostgresSchemaIR as t };
+//# sourceMappingURL=postgres-schema-ir-BJl_a3J7.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-BJl_a3J7.d.mts","names":[],"sources":["../src/core/schema-ir/postgres-table-ir.ts","../src/core/schema-ir/postgres-schema-ir.ts"],"mappings":";;;;;;UAeiB,oBAAA,SAA6B,eAAe;EAAA,SAClD,WAAA,YAAuB,iBAAA;AAAA;AADlC;;;;;;;;AACmD;AAenD;;;AAhBA,cAgBa,eAAA,SAAwB,eAAA,YAA2B,YAAA;EAAA,SACrD,IAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,WAAA;EAAA,SACjC,WAAA,EAAa,aAAA,CAAc,eAAA;EAAA,SAC3B,OAAA,EAAS,aAAA,CAAc,WAAA;EAAA,SACvB,OAAA,EAAS,aAAA,CAAc,UAAA;EAAA,SACf,UAAA,GAAa,UAAA;EAAA,SACb,WAAA,GAAc,cAAA;EAAA,SACd,MAAA,GAAS,aAAA,CAAc,oBAAA;EAAA,SAC/B,WAAA,WAAsB,iBAAA;cAEnB,KAAA,EAAO,oBAAA;EAAA,IAsCf,EAAA;EAIJ,SAAA,CAAU,MAAA,EAAQ,YAAA;EAIlB,QAAA,aAAqB,YAAA;AAAA;AAAA,iBAKP,iBAAA,CAAkB,IAAA,EAAM,YAAA,GAAe,IAAA,IAAQ,eAAe;;;UC/E7D,qBAAA;EAAA,SACN,MAAA,EAAQ,MAAA,SAEf,eAAA,IAAmB,eAAA;IAAoB,WAAA,YAAuB,iBAAA;EAAA;EAAA,SAEvD,YAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;AAAA;ADQX;;;;;;;;;;;;;;;;;AAAA,cCYa,gBAAA,SAAyB,eAAA,YAA2B,YAAA;EAAA,SACtD,UAAA,EAAY,eAAA;EAAA,SACZ,MAAA,EAAQ,QAAA,CAAS,MAAA,SAAe,eAAA;EAAA,SACxB,WAAA,GAAc,cAAA;EAAA,SACtB,YAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;cAEG,KAAA,EAAO,qBAAA;EAAA,IAgCf,EAAA;EAAA,IAIA,WAAA,aAAwB,iBAAA;EAI5B,SAAA,CAAU,MAAA,EAAQ,YAAA;EAIlB,QAAA,aAAqB,YAAA;AAAA;;;;;;;;;;;iBAeP,kBAAA,CAAmB,MAAA,EAAQ,WAAA,GAAc,MAAA,IAAU,gBAAgB;AAAA,iBAInE,sBAAA,CAAuB,MAAA,EAAQ,WAAA,WAAsB,MAAA,IAAU,gBAAgB;;;;;;iBAa/E,sBAAA,CAAuB,MAAA,EAAQ,gBAAA,GAAmB,gBAAgB"}

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

@@ -0,0 +1,133 @@
+import { blindCast } from "@prisma-next/utils/casts";
+import { freezeNode } from "@prisma-next/framework-components/ir";
+import { PrimaryKey, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+//#region src/core/schema-ir/postgres-table-ir.ts
+/**
+* Postgres-specific table IR node. Carries all `SqlTableIR` fields plus
+* `rlsPolicies`, and implements `DiffableNode` so the table instance is
+* directly the diff-tree node — no separate wrapper needed.
+*
+* Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because
+* `SqlTableIR` calls `freezeNode` in its own constructor, which prevents
+* subclass field initialisation. Same pattern as `PostgresSchemaIR`.
+*
+* `id` is the table name. `children()` returns the policies on this table.
+* `isEqualTo` is always true — table-level attributes are not diffed yet.
+*/
+var PostgresTableIR = class extends SqlSchemaIRNode {
+	name;
+	columns;
+	foreignKeys;
+	uniques;
+	indexes;
+	rlsPolicies;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([key, col]) => [key, col instanceof SqlColumnIR ? col : new SqlColumnIR(col)])));
+		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk)));
+		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u)));
+		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof SqlIndexIR ? i : new SqlIndexIR(i)));
+		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((c) => c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c)));
+		this.rlsPolicies = Object.freeze([...input.rlsPolicies ?? []]);
+		freezeNode(this);
+	}
+	get id() {
+		return this.name;
+	}
+	isEqualTo(_other) {
+		return true;
+	}
+	children() {
+		return this.rlsPolicies;
+	}
+};
+function isPostgresTableIR(node) {
+	return node instanceof PostgresTableIR;
+}
+//#endregion
+//#region src/core/schema-ir/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.
+*
+* `tables` holds `PostgresTableIR` instances which carry their own RLS
+* policies. `children()` returns the tables directly — the table instances
+* ARE the diff-tree nodes.
+*
+* Nothing RLS-specific leaks into the sql-family layer.
+*/
+var PostgresSchemaIR = class extends SqlSchemaIRNode {
+	nodeTarget = "postgres";
+	tables;
+	pgSchemaName;
+	pgVersion;
+	roles;
+	existingSchemas;
+	nativeEnumTypeNames;
+	constructor(input) {
+		super();
+		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables).map(([key, t]) => [key, t instanceof PostgresTableIR ? t : new PostgresTableIR(t)])));
+		this.pgSchemaName = input.pgSchemaName;
+		this.pgVersion = input.pgVersion;
+		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);
+	}
+	get id() {
+		return this.pgSchemaName;
+	}
+	get rlsPolicies() {
+		return Object.values(this.tables).flatMap((t) => t.rlsPolicies);
+	}
+	isEqualTo(_other) {
+		return true;
+	}
+	children() {
+		return Object.values(this.tables);
+	}
+};
+/**
+* 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";
+}
+function assertPostgresSchemaIR(schema) {
+	if (!isPostgresSchemaIR(schema)) throw new Error(`planPostgresSchemaDiff: expected a PostgresSchemaIR but got nodeTarget=${String(schema.nodeTarget ?? typeof schema)}`);
+}
+/**
+* Returns `schema` as-is when it is a real `PostgresSchemaIR` instance, or
+* reconstructs one when `projectSchemaToSpace` has spread the class into a
+* plain object (losing prototype methods).
+*/
+function ensurePostgresSchemaIR(schema) {
+	if (schema instanceof PostgresSchemaIR) return schema;
+	return new PostgresSchemaIR(blindCast(schema));
+}
+//#endregion
+export { PostgresTableIR as a, isPostgresSchemaIR as i, assertPostgresSchemaIR as n, isPostgresTableIR as o, ensurePostgresSchemaIR as r, PostgresSchemaIR as t };
+
+//# sourceMappingURL=postgres-schema-ir-I_FiUndw.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-I_FiUndw.mjs","names":[],"sources":["../src/core/schema-ir/postgres-table-ir.ts","../src/core/schema-ir/postgres-schema-ir.ts"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  PrimaryKey,\n  type SqlAnnotations,\n  SqlCheckConstraintIR,\n  SqlColumnIR,\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlSchemaIRNode,\n  type SqlTableIRInput,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\n\nexport interface PostgresTableIRInput extends SqlTableIRInput {\n  readonly rlsPolicies?: readonly PostgresRlsPolicy[];\n}\n\n/**\n * Postgres-specific table IR node. Carries all `SqlTableIR` fields plus\n * `rlsPolicies`, and implements `DiffableNode` so the table instance is\n * directly the diff-tree node — no separate wrapper needed.\n *\n * Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because\n * `SqlTableIR` calls `freezeNode` in its own constructor, which prevents\n * subclass field initialisation. Same pattern as `PostgresSchemaIR`.\n *\n * `id` is the table name. `children()` returns the policies on this table.\n * `isEqualTo` is always true — table-level attributes are not diffed yet.\n */\nexport class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {\n  readonly name: string;\n  readonly columns: Readonly<Record<string, SqlColumnIR>>;\n  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;\n  readonly uniques: ReadonlyArray<SqlUniqueIR>;\n  readonly indexes: ReadonlyArray<SqlIndexIR>;\n  declare readonly primaryKey?: PrimaryKey;\n  declare readonly annotations?: SqlAnnotations;\n  declare readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;\n  readonly rlsPolicies: readonly PostgresRlsPolicy[];\n\n  constructor(input: PostgresTableIRInput) {\n    super();\n    this.name = input.name;\n    this.columns = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.columns).map(([key, col]) => [\n          key,\n          col instanceof SqlColumnIR ? col : new SqlColumnIR(col),\n        ]),\n      ),\n    );\n    this.foreignKeys = Object.freeze(\n      input.foreignKeys.map((fk) => (fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk))),\n    );\n    this.uniques = Object.freeze(\n      input.uniques.map((u) => (u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u))),\n    );\n    this.indexes = Object.freeze(\n      input.indexes.map((i) => (i instanceof SqlIndexIR ? i : new SqlIndexIR(i))),\n    );\n    if (input.primaryKey !== undefined) {\n      this.primaryKey =\n        input.primaryKey instanceof PrimaryKey\n          ? input.primaryKey\n          : new PrimaryKey(input.primaryKey);\n    }\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    if (input.checks !== undefined && input.checks.length > 0) {\n      this.checks = Object.freeze(\n        input.checks.map((c) =>\n          c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c),\n        ),\n      );\n    }\n    this.rlsPolicies = Object.freeze([...(input.rlsPolicies ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  isEqualTo(_other: DiffableNode): boolean {\n    return true;\n  }\n\n  children(): readonly DiffableNode[] {\n    return this.rlsPolicies;\n  }\n}\n\nexport function isPostgresTableIR(node: DiffableNode): node is PostgresTableIR {\n  return node instanceof PostgresTableIR;\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  type SqlAnnotations,\n  type SqlSchemaIR,\n  SqlSchemaIRNode,\n  type SqlSchemaTarget,\n  type SqlTableIRInput,\n} from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './postgres-role';\nimport { PostgresTableIR } from './postgres-table-ir';\n\nexport interface PostgresSchemaIRInput {\n  readonly tables: Record<\n    string,\n    PostgresTableIR | (SqlTableIRInput & { rlsPolicies?: readonly PostgresRlsPolicy[] })\n  >;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\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 * `tables` holds `PostgresTableIR` instances which carry their own RLS\n * policies. `children()` returns the tables directly — the table instances\n * ARE the diff-tree nodes.\n *\n * Nothing RLS-specific leaks into the sql-family layer.\n */\nexport class PostgresSchemaIR extends SqlSchemaIRNode implements DiffableNode {\n  readonly nodeTarget: SqlSchemaTarget = 'postgres';\n  readonly tables: Readonly<Record<string, PostgresTableIR>>;\n  declare readonly annotations?: SqlAnnotations;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\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 PostgresTableIR ? t : new PostgresTableIR(t),\n        ]),\n      ),\n    );\n    this.pgSchemaName = input.pgSchemaName;\n    this.pgVersion = input.pgVersion;\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).\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  get id(): string {\n    return this.pgSchemaName;\n  }\n\n  get rlsPolicies(): readonly PostgresRlsPolicy[] {\n    return Object.values(this.tables).flatMap((t) => t.rlsPolicies);\n  }\n\n  isEqualTo(_other: DiffableNode): boolean {\n    return true;\n  }\n\n  children(): readonly DiffableNode[] {\n    return Object.values(this.tables);\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\nexport function assertPostgresSchemaIR(schema: SqlSchemaIR): asserts schema is PostgresSchemaIR {\n  if (!isPostgresSchemaIR(schema)) {\n    throw new Error(\n      `planPostgresSchemaDiff: expected a PostgresSchemaIR but got nodeTarget=${String(schema.nodeTarget ?? typeof schema)}`,\n    );\n  }\n}\n\n/**\n * Returns `schema` as-is when it is a real `PostgresSchemaIR` instance, or\n * reconstructs one when `projectSchemaToSpace` has spread the class into a\n * plain object (losing prototype methods).\n */\nexport function ensurePostgresSchemaIR(schema: PostgresSchemaIR): PostgresSchemaIR {\n  if (schema instanceof PostgresSchemaIR) return schema;\n  return new PostgresSchemaIR(\n    blindCast<\n      PostgresSchemaIRInput,\n      'spread objects from projectSchemaToSpace preserve all own-enumerable fields'\n    >(schema),\n  );\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,14 @@
+import { r as isPostgresSchema } from "./postgres-schema-DLcc3W2-.mjs";
+import { i as isPostgresSchemaIR } from "./postgres-schema-ir-I_FiUndw.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+//#region src/core/schema-ir/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-BbDSiwx2.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-annotations-BbDSiwx2.mjs","names":[],"sources":["../src/core/schema-ir/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,6 +1,6 @@
 import { AnyCodecDescriptor } from "@prisma-next/framework-components/codec";
-import { Namespace } from "@prisma-next/framework-components/ir";
-import { SqlNamespaceTablesInput, SqlStorage } from "@prisma-next/sql-contract/types";
+import { AnyEntityKindDescriptor, Namespace } from "@prisma-next/framework-components/ir";
+import { SqlNamespaceInput, SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { Contract } from "@prisma-next/contract/types";
 import { RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma-next/framework-components/execution";
@@ -8,11 +8,11 @@ import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/core/postgres-contract-serializer.d.ts
 declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
-  constructor();
-  protected get defaultNamespaceId(): string;
-  protected hydrateSqlNamespaceEntry(nsId: string, raw: Namespace | Record<string, unknown>): Namespace | SqlNamespaceTablesInput;
+  constructor(extraPackEntityKinds?: readonly AnyEntityKindDescriptor[]);
+  protected hydrateSqlNamespaceEntry(nsId: string, raw: Record<string, unknown>): Namespace | SqlNamespaceInput;
   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":";;;;;;;;;cAmEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;cACrE,oBAAA,YAA+B,uBAAA;EAAA,UAKxB,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,MAAA,oBACJ,SAAA,GAAY,iBAAA;EAyBN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QA0CpD,0BAAA;EAAA,QAgCA,mBAAA;EAAA,QAOA,kBAAA;AAAA;;;UC7KO,6BAAA,SAAsC,qBAAqB;;;;;AD0D5E;;cClDM,+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 { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-D5zHFKUz.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-tGMiJcl4.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/schema-ir/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/schema-ir/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-BbDSiwx2.mjs";
+export { resolveDdlSchemaForNamespaceStorage };