@prisma-next/target-postgres 0.16.0-dev.32 → 0.16.0-dev.34

package/dist/{postgres-migration--BzvpA92.mjs.map → postgres-migration-D_6w1hJj.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-migration--BzvpA92.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { PostgresContractView } from '../postgres-contract-view';\nimport { PostgresRlsPolicy, type PostgresRlsPolicyInput } from '../postgres-rls-policy';\nimport {\n  AddCheckConstraintCall,\n  AddColumnCall,\n  AddForeignKeyCall,\n  AddNativeEnumValueCall,\n  AddPrimaryKeyCall,\n  AddUniqueCall,\n  AlterColumnTypeCall,\n  type AlterColumnTypeOptions,\n  CreateIndexCall,\n  CreateNativeEnumTypeCall,\n  CreatePostgresRlsPolicyCall,\n  CreateSchemaCall,\n  CreateTableCall,\n  DisableRowLevelSecurityCall,\n  DropCheckConstraintCall,\n  DropColumnCall,\n  DropConstraintCall,\n  DropDefaultCall,\n  DropIndexCall,\n  DropNativeEnumTypeCall,\n  DropNotNullCall,\n  DropPostgresRlsPolicyCall,\n  DropTableCall,\n  EnableRowLevelSecurityCall,\n  RenameIndexCall,\n  RenamePostgresRlsPolicyCall,\n  SetDefaultCall,\n  SetNotNullCall,\n} from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport { installExtension } from './operations/dependencies';\nimport type { CreateIndexExtras } from './operations/indexes';\nimport type { ForeignKeySpec } from './operations/shared';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n *\n * Every method requires an explicit `schema`. Postgres migrations name their\n * schema deliberately — there is no default and no `search_path`-relative\n * option. A migration that left the schema unspecified would resolve against\n * whatever `search_path` the connection happened to carry, and that ambiguity\n * is an antipattern in a migration. (The unbound/unspecified namespace concept\n * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)\n */\nexport abstract class PostgresMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<PostgresPlanTargetDetails, 'postgres', Start, End> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `controlAdapterFor`\n   * throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  #endView = new MigrationContractViews<PostgresContractView<End>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<PostgresContractView<Start>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Returns the materialized control adapter, or throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING naming\n   * `operation` when the migration was constructed without a `ControlStack`.\n   * Single home for the null-check that every DDL/DML method shares.\n   */\n  private controlAdapterFor(operation: string): SqlControlAdapter<'postgres'> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing(operation);\n    }\n    return this.controlAdapter;\n  }\n\n  /**\n   * The typed, schema-qualified Postgres view over this migration's end-state\n   * contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws\n   * if no `endContractJson` was provided.\n   */\n  get endContract(): PostgresContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed Postgres view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): PostgresContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return dataTransform(contract, name, options, this.controlAdapterFor('dataTransform'));\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateTableCall(\n      options.schema,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapterFor('createTable'));\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapterFor('createSchema'));\n  }\n\n  /**\n   * Emit a `CREATE TYPE ... AS ENUM (...)` migration operation for a managed\n   * native enum. Builds a typed DDL node and lowers it through the stored\n   * control adapter (members render in declaration order). Throws if no adapter\n   * is present.\n   */\n  protected createNativeEnumType(options: {\n    readonly schema: string;\n    readonly typeName: string;\n    readonly members: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateNativeEnumTypeCall(options.schema, options.typeName, options.members).toOp(\n      this.controlAdapterFor('createNativeEnumType'),\n    );\n  }\n\n  /**\n   * Emit a `DROP TYPE` migration operation for a managed native enum, lowered\n   * through the stored control adapter. Throws if no adapter is present.\n   */\n  protected dropNativeEnumType(options: {\n    readonly schema: string;\n    readonly typeName: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropNativeEnumTypeCall(options.schema, options.typeName).toOp(\n      this.controlAdapterFor('dropNativeEnumType'),\n    );\n  }\n\n  /**\n   * Emit an `ALTER TYPE ... ADD VALUE` migration operation appending one\n   * member to a managed native enum, lowered through the stored control\n   * adapter. Throws if no adapter is present. Every appended value is its\n   * own operation — call this once per value to append more than one.\n   */\n  protected addNativeEnumValue(options: {\n    readonly schema: string;\n    readonly typeName: string;\n    readonly value: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddNativeEnumValueCall(options.schema, options.typeName, options.value).toOp(\n      this.controlAdapterFor('addNativeEnumValue'),\n    );\n  }\n\n  protected addColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: DdlColumn;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('addColumn'),\n    );\n  }\n\n  protected addPrimaryKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddPrimaryKeyCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapterFor('addPrimaryKey'));\n  }\n\n  protected addUnique(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddUniqueCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapterFor('addUnique'));\n  }\n\n  protected addForeignKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly foreignKey: ForeignKeySpec;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(\n      this.controlAdapterFor('addForeignKey'),\n    );\n  }\n\n  protected addCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly column: string;\n    readonly values: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddCheckConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.column,\n      options.values,\n    ).toOp(this.controlAdapterFor('addCheckConstraint'));\n  }\n\n  protected dropCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(\n      this.controlAdapterFor('dropCheckConstraint'),\n    );\n  }\n\n  protected dropConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.kind ?? 'unique',\n    ).toOp(this.controlAdapterFor('dropConstraint'));\n  }\n\n  protected dropTable(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropTableCall(options.schema, options.table).toOp(\n      this.controlAdapterFor('dropTable'),\n    );\n  }\n\n  protected dropColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropColumn'),\n    );\n  }\n\n  protected alterColumnType(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly options: AlterColumnTypeOptions;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AlterColumnTypeCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.options,\n    ).toOp(this.controlAdapterFor('alterColumnType'));\n  }\n\n  protected setNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new SetNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('setNotNull'),\n    );\n  }\n\n  protected dropNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropNotNull'),\n    );\n  }\n\n  protected setDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly defaultSql: string;\n    readonly operationClass?: 'additive' | 'widening';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new SetDefaultCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.defaultSql,\n      options.operationClass,\n    ).toOp(this.controlAdapterFor('setDefault'));\n  }\n\n  protected dropDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropDefaultCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropDefault'),\n    );\n  }\n\n  protected createIndex(\n    options: {\n      readonly schema: string;\n      readonly table: string;\n      readonly index: string;\n      readonly extras?: CreateIndexExtras;\n    } & (\n      | { readonly columns: readonly string[]; readonly expression?: never }\n      | { readonly expression: string; readonly columns?: never }\n    ),\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateIndexCall(\n      options.schema,\n      options.table,\n      options.index,\n      options.columns !== undefined\n        ? { columns: options.columns }\n        : { expression: options.expression },\n      options.extras,\n    ).toOp(this.controlAdapterFor('createIndex'));\n  }\n\n  protected renameIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly from: string;\n    readonly to: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new RenameIndexCall(options.schema, options.table, options.from, options.to).toOp(\n      this.controlAdapterFor('renameIndex'),\n    );\n  }\n\n  protected dropIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropIndexCall(options.schema, options.table, options.index).toOp(\n      this.controlAdapterFor('dropIndex'),\n    );\n  }\n\n  protected installExtension(options: {\n    readonly extensionName: string;\n    readonly invariantId: string;\n    readonly id: string;\n    readonly label?: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return installExtension(options, this.controlAdapterFor('installExtension'));\n  }\n\n  protected enableRowLevelSecurity(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new EnableRowLevelSecurityCall(options.schema, options.table).toOp(\n      this.controlAdapterFor('enableRowLevelSecurity'),\n    );\n  }\n\n  protected disableRowLevelSecurity(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DisableRowLevelSecurityCall(options.schema, options.table).toOp(\n      this.controlAdapterFor('disableRowLevelSecurity'),\n    );\n  }\n\n  protected createRlsPolicy(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly policy: PostgresRlsPolicyInput;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreatePostgresRlsPolicyCall(\n      options.schema,\n      options.table,\n      new PostgresRlsPolicy(options.policy),\n    ).toOp(this.controlAdapterFor('createRlsPolicy'));\n  }\n\n  protected dropRlsPolicy(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly policy: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropPostgresRlsPolicyCall(options.schema, options.table, options.policy).toOp(\n      this.controlAdapterFor('dropRlsPolicy'),\n    );\n  }\n\n  protected renameRlsPolicy(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly from: string;\n    readonly to: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new RenamePostgresRlsPolicyCall(\n      options.schema,\n      options.table,\n      options.from,\n      options.to,\n    ).toOp(this.controlAdapterFor('renameRlsPolicy'));\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"postgres-migration-D_6w1hJj.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { PostgresContractView } from '../postgres-contract-view';\nimport { PostgresRlsPolicy, type PostgresRlsPolicyInput } from '../postgres-rls-policy';\nimport {\n  AddCheckConstraintCall,\n  AddColumnCall,\n  AddForeignKeyCall,\n  AddNativeEnumValueCall,\n  AddPrimaryKeyCall,\n  AddUniqueCall,\n  AlterColumnTypeCall,\n  type AlterColumnTypeOptions,\n  CreateIndexCall,\n  CreateNativeEnumTypeCall,\n  CreatePostgresRlsPolicyCall,\n  CreateSchemaCall,\n  CreateTableCall,\n  DisableRowLevelSecurityCall,\n  DropCheckConstraintCall,\n  DropColumnCall,\n  DropConstraintCall,\n  DropDefaultCall,\n  DropIndexCall,\n  DropNativeEnumTypeCall,\n  DropNotNullCall,\n  DropPostgresRlsPolicyCall,\n  DropTableCall,\n  EnableRowLevelSecurityCall,\n  RenameIndexCall,\n  RenamePostgresRlsPolicyCall,\n  SetDefaultCall,\n  SetNotNullCall,\n} from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport { installExtension } from './operations/dependencies';\nimport type { CreateIndexExtras } from './operations/indexes';\nimport type { ForeignKeySpec } from './operations/shared';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n *\n * Every method requires an explicit `schema`. Postgres migrations name their\n * schema deliberately — there is no default and no `search_path`-relative\n * option. A migration that left the schema unspecified would resolve against\n * whatever `search_path` the connection happened to carry, and that ambiguity\n * is an antipattern in a migration. (The unbound/unspecified namespace concept\n * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)\n */\nexport abstract class PostgresMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<PostgresPlanTargetDetails, 'postgres', Start, End> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `controlAdapterFor`\n   * throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  #endView = new MigrationContractViews<PostgresContractView<End>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<PostgresContractView<Start>>(\n    this,\n    'PostgresMigration',\n    (json) => PostgresContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Returns the materialized control adapter, or throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING naming\n   * `operation` when the migration was constructed without a `ControlStack`.\n   * Single home for the null-check that every DDL/DML method shares.\n   */\n  private controlAdapterFor(operation: string): SqlControlAdapter<'postgres'> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing(operation);\n    }\n    return this.controlAdapter;\n  }\n\n  /**\n   * The typed, schema-qualified Postgres view over this migration's end-state\n   * contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws\n   * if no `endContractJson` was provided.\n   */\n  get endContract(): PostgresContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed Postgres view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): PostgresContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return dataTransform(contract, name, options, this.controlAdapterFor('dataTransform'));\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateTableCall(\n      options.schema,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapterFor('createTable'));\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapterFor('createSchema'));\n  }\n\n  /**\n   * Emit a `CREATE TYPE ... AS ENUM (...)` migration operation for a managed\n   * native enum. Builds a typed DDL node and lowers it through the stored\n   * control adapter (members render in declaration order). Throws if no adapter\n   * is present.\n   */\n  protected createNativeEnumType(options: {\n    readonly schema: string;\n    readonly typeName: string;\n    readonly members: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateNativeEnumTypeCall(options.schema, options.typeName, options.members).toOp(\n      this.controlAdapterFor('createNativeEnumType'),\n    );\n  }\n\n  /**\n   * Emit a `DROP TYPE` migration operation for a managed native enum, lowered\n   * through the stored control adapter. Throws if no adapter is present.\n   */\n  protected dropNativeEnumType(options: {\n    readonly schema: string;\n    readonly typeName: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropNativeEnumTypeCall(options.schema, options.typeName).toOp(\n      this.controlAdapterFor('dropNativeEnumType'),\n    );\n  }\n\n  /**\n   * Emit an `ALTER TYPE ... ADD VALUE` migration operation appending one\n   * member to a managed native enum, lowered through the stored control\n   * adapter. Throws if no adapter is present. Every appended value is its\n   * own operation — call this once per value to append more than one.\n   */\n  protected addNativeEnumValue(options: {\n    readonly schema: string;\n    readonly typeName: string;\n    readonly value: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddNativeEnumValueCall(options.schema, options.typeName, options.value).toOp(\n      this.controlAdapterFor('addNativeEnumValue'),\n    );\n  }\n\n  protected addColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: DdlColumn;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('addColumn'),\n    );\n  }\n\n  protected addPrimaryKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddPrimaryKeyCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapterFor('addPrimaryKey'));\n  }\n\n  protected addUnique(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly columns: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddUniqueCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.columns,\n    ).toOp(this.controlAdapterFor('addUnique'));\n  }\n\n  protected addForeignKey(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly foreignKey: ForeignKeySpec;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(\n      this.controlAdapterFor('addForeignKey'),\n    );\n  }\n\n  protected addCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly column: string;\n    readonly values: readonly string[];\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AddCheckConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.column,\n      options.values,\n    ).toOp(this.controlAdapterFor('addCheckConstraint'));\n  }\n\n  protected dropCheckConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(\n      this.controlAdapterFor('dropCheckConstraint'),\n    );\n  }\n\n  protected dropConstraint(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly constraint: string;\n    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropConstraintCall(\n      options.schema,\n      options.table,\n      options.constraint,\n      options.kind ?? 'unique',\n    ).toOp(this.controlAdapterFor('dropConstraint'));\n  }\n\n  protected dropTable(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropTableCall(options.schema, options.table).toOp(\n      this.controlAdapterFor('dropTable'),\n    );\n  }\n\n  protected dropColumn(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropColumnCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropColumn'),\n    );\n  }\n\n  protected alterColumnType(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly options: AlterColumnTypeOptions;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new AlterColumnTypeCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.options,\n    ).toOp(this.controlAdapterFor('alterColumnType'));\n  }\n\n  protected setNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new SetNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('setNotNull'),\n    );\n  }\n\n  protected dropNotNull(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropNotNullCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropNotNull'),\n    );\n  }\n\n  protected setDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n    readonly defaultSql: string;\n    readonly operationClass?: 'additive' | 'widening';\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new SetDefaultCall(\n      options.schema,\n      options.table,\n      options.column,\n      options.defaultSql,\n      options.operationClass,\n    ).toOp(this.controlAdapterFor('setDefault'));\n  }\n\n  protected dropDefault(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly column: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropDefaultCall(options.schema, options.table, options.column).toOp(\n      this.controlAdapterFor('dropDefault'),\n    );\n  }\n\n  protected createIndex(\n    options: {\n      readonly schema: string;\n      readonly table: string;\n      readonly index: string;\n      readonly extras?: CreateIndexExtras;\n    } & (\n      | { readonly columns: readonly string[]; readonly expression?: never }\n      | { readonly expression: string; readonly columns?: never }\n    ),\n  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreateIndexCall(\n      options.schema,\n      options.table,\n      options.index,\n      options.columns !== undefined\n        ? { columns: options.columns }\n        : { expression: options.expression },\n      options.extras,\n    ).toOp(this.controlAdapterFor('createIndex'));\n  }\n\n  protected renameIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly from: string;\n    readonly to: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new RenameIndexCall(options.schema, options.table, options.from, options.to).toOp(\n      this.controlAdapterFor('renameIndex'),\n    );\n  }\n\n  protected dropIndex(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly index: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropIndexCall(options.schema, options.table, options.index).toOp(\n      this.controlAdapterFor('dropIndex'),\n    );\n  }\n\n  protected installExtension(options: {\n    readonly extensionName: string;\n    readonly invariantId: string;\n    readonly id: string;\n    readonly label?: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return installExtension(options, this.controlAdapterFor('installExtension'));\n  }\n\n  protected enableRowLevelSecurity(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new EnableRowLevelSecurityCall(options.schema, options.table).toOp(\n      this.controlAdapterFor('enableRowLevelSecurity'),\n    );\n  }\n\n  protected disableRowLevelSecurity(options: {\n    readonly schema: string;\n    readonly table: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DisableRowLevelSecurityCall(options.schema, options.table).toOp(\n      this.controlAdapterFor('disableRowLevelSecurity'),\n    );\n  }\n\n  protected createRlsPolicy(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly policy: PostgresRlsPolicyInput;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new CreatePostgresRlsPolicyCall(\n      options.schema,\n      options.table,\n      new PostgresRlsPolicy(options.policy),\n    ).toOp(this.controlAdapterFor('createRlsPolicy'));\n  }\n\n  protected dropRlsPolicy(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly policy: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new DropPostgresRlsPolicyCall(options.schema, options.table, options.policy).toOp(\n      this.controlAdapterFor('dropRlsPolicy'),\n    );\n  }\n\n  protected renameRlsPolicy(options: {\n    readonly schema: string;\n    readonly table: string;\n    readonly from: string;\n    readonly to: string;\n  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {\n    return new RenamePostgresRlsPolicyCall(\n      options.schema,\n      options.table,\n      options.from,\n      options.to,\n    ).toOp(this.controlAdapterFor('renameRlsPolicy'));\n  }\n}\n"],"mappings":"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"}

package/dist/{postgres-native-enum-BwVNf0Ku.mjs → postgres-native-enum-DqjHPN11.mjs}

@@ -1,5 +1,5 @@
-import { freezeNode } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
+import { freezeNode } from "@prisma-next/framework-components/ir";
 import { SqlNode } from "@prisma-next/sql-contract/types";
 //#region src/core/postgres-native-enum.ts
 function freezeMembers(members) {
@@ -42,4 +42,4 @@ var PostgresNativeEnum = class extends SqlNode {
 //#endregion
 export { PostgresNativeEnum as t };
 
-//# sourceMappingURL=postgres-native-enum-BwVNf0Ku.mjs.map
+//# sourceMappingURL=postgres-native-enum-DqjHPN11.mjs.map

package/dist/{postgres-native-enum-BwVNf0Ku.mjs.map → postgres-native-enum-DqjHPN11.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-native-enum-BwVNf0Ku.mjs","names":[],"sources":["../src/core/postgres-native-enum.ts"],"sourcesContent":["import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\n\nexport interface PostgresNativeEnumInput<Members extends readonly string[] = readonly string[]> {\n  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */\n  readonly typeName: string;\n  /** Member values in declaration order — this is the Postgres enum sort order. */\n  readonly members: Members;\n  readonly control?: ControlPolicy;\n}\n\nfunction freezeMembers<Members extends readonly string[]>(members: Members): Members {\n  return blindCast<\n    Members,\n    'Object.freeze clones+freezes the tuple for immutability; the clone widens to readonly string[], but it holds exactly the values of members (already typed Members)'\n  >(Object.freeze([...members]));\n}\n\n/**\n * Postgres contract-IR class for a native enum type (`CREATE TYPE … AS ENUM (…)`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree will use `PostgresNativeEnumSchemaNode` when the managed phase\n * builds it.\n *\n * A member is a value, not a name→value pair — matching `CREATE TYPE … AS ENUM\n * ('a', 'b')`, which has no separate member name.\n *\n * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly,\n * frozen at construction via `freezeNode(this)`. The `kind: 'postgres-enum'`\n * discriminant is enumerable so it survives JSON. Lives at\n * `storage.namespaces[ns].entries.native_enum[HandleName]`; the entries key\n * (`native_enum`) is the entity-kind descriptor's `kind`, decoupled from this\n * node's own `kind` literal — the same shape as `table`/`StorageTable` and\n * `valueSet`/`StorageValueSet`.\n */\nexport class PostgresNativeEnum<\n  Members extends readonly string[] = readonly string[],\n> extends SqlNode {\n  static is(node: unknown): node is PostgresNativeEnum {\n    return (\n      typeof node === 'object' && node !== null && 'kind' in node && node.kind === 'postgres-enum'\n    );\n  }\n\n  override readonly kind = 'postgres-enum' as const;\n  readonly typeName: string;\n  readonly members: Members;\n  declare readonly control?: ControlPolicy;\n\n  constructor(input: PostgresNativeEnumInput<Members>) {\n    super();\n    this.typeName = input.typeName;\n    this.members = freezeMembers(input.members);\n    if (input.control !== undefined) this.control = input.control;\n    freezeNode(this);\n  }\n}\n"],"mappings":";;;;AAaA,SAAS,cAAiD,SAA2B;CACnF,OAAO,UAGL,OAAO,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAC/B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,qBAAb,cAEU,QAAQ;CAChB,OAAO,GAAG,MAA2C;EACnD,OACE,OAAO,SAAS,YAAY,SAAS,QAAQ,UAAU,QAAQ,KAAK,SAAS;CAEjF;CAEA,OAAyB;CACzB;CACA;CAGA,YAAY,OAAyC;EACnD,MAAM;EACN,KAAK,WAAW,MAAM;EACtB,KAAK,UAAU,cAAc,MAAM,OAAO;EAC1C,IAAI,MAAM,YAAY,KAAA,GAAW,KAAK,UAAU,MAAM;EACtD,WAAW,IAAI;CACjB;AACF"}
+{"version":3,"file":"postgres-native-enum-DqjHPN11.mjs","names":[],"sources":["../src/core/postgres-native-enum.ts"],"sourcesContent":["import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\n\nexport interface PostgresNativeEnumInput<Members extends readonly string[] = readonly string[]> {\n  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */\n  readonly typeName: string;\n  /** Member values in declaration order — this is the Postgres enum sort order. */\n  readonly members: Members;\n  readonly control?: ControlPolicy;\n}\n\nfunction freezeMembers<Members extends readonly string[]>(members: Members): Members {\n  return blindCast<\n    Members,\n    'Object.freeze clones+freezes the tuple for immutability; the clone widens to readonly string[], but it holds exactly the values of members (already typed Members)'\n  >(Object.freeze([...members]));\n}\n\n/**\n * Postgres contract-IR class for a native enum type (`CREATE TYPE … AS ENUM (…)`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree will use `PostgresNativeEnumSchemaNode` when the managed phase\n * builds it.\n *\n * A member is a value, not a name→value pair — matching `CREATE TYPE … AS ENUM\n * ('a', 'b')`, which has no separate member name.\n *\n * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly,\n * frozen at construction via `freezeNode(this)`. The `kind: 'postgres-enum'`\n * discriminant is enumerable so it survives JSON. Lives at\n * `storage.namespaces[ns].entries.native_enum[HandleName]`; the entries key\n * (`native_enum`) is the entity-kind descriptor's `kind`, decoupled from this\n * node's own `kind` literal — the same shape as `table`/`StorageTable` and\n * `valueSet`/`StorageValueSet`.\n */\nexport class PostgresNativeEnum<\n  Members extends readonly string[] = readonly string[],\n> extends SqlNode {\n  static is(node: unknown): node is PostgresNativeEnum {\n    return (\n      typeof node === 'object' && node !== null && 'kind' in node && node.kind === 'postgres-enum'\n    );\n  }\n\n  override readonly kind = 'postgres-enum' as const;\n  readonly typeName: string;\n  readonly members: Members;\n  declare readonly control?: ControlPolicy;\n\n  constructor(input: PostgresNativeEnumInput<Members>) {\n    super();\n    this.typeName = input.typeName;\n    this.members = freezeMembers(input.members);\n    if (input.control !== undefined) this.control = input.control;\n    freezeNode(this);\n  }\n}\n"],"mappings":";;;;AAaA,SAAS,cAAiD,SAA2B;CACnF,OAAO,UAGL,OAAO,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAC/B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,qBAAb,cAEU,QAAQ;CAChB,OAAO,GAAG,MAA2C;EACnD,OACE,OAAO,SAAS,YAAY,SAAS,QAAQ,UAAU,QAAQ,KAAK,SAAS;CAEjF;CAEA,OAAyB;CACzB;CACA;CAGA,YAAY,OAAyC;EACnD,MAAM;EACN,KAAK,WAAW,MAAM;EACtB,KAAK,UAAU,cAAc,MAAM,OAAO;EAC1C,IAAI,MAAM,YAAY,KAAA,GAAW,KAAK,UAAU,MAAM;EACtD,WAAW,IAAI;CACjB;AACF"}

package/dist/{postgres-role-schema-node-bg32e7I-.mjs → postgres-role-schema-node-DOkim7QI.mjs}

@@ -1,6 +1,6 @@
-import { r as PostgresSchemaNodeKind } from "./postgres-table-schema-node-D6LvInCe.mjs";
-import { freezeNode } from "@prisma-next/framework-components/ir";
+import { r as PostgresSchemaNodeKind } from "./postgres-table-schema-node-DXzwiu16.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
+import { freezeNode } from "@prisma-next/framework-components/ir";
 import { SqlSchemaIRNode, assertNode, defineNonEnumerable } from "@prisma-next/sql-schema-ir/types";
 //#region src/core/schema-ir/postgres-database-schema-node.ts
 /**
@@ -188,4 +188,4 @@ var PostgresRoleSchemaNode = class PostgresRoleSchemaNode extends SqlSchemaIRNod
 //#endregion
 export { PostgresDatabaseSchemaNode as i, PostgresPolicySchemaNode as n, PostgresNamespaceSchemaNode as r, PostgresRoleSchemaNode as t };
 
-//# sourceMappingURL=postgres-role-schema-node-bg32e7I-.mjs.map
+//# sourceMappingURL=postgres-role-schema-node-DOkim7QI.mjs.map

package/dist/{postgres-role-schema-node-bg32e7I-.mjs.map → postgres-role-schema-node-DOkim7QI.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-role-schema-node-bg32e7I-.mjs","names":[],"sources":["../src/core/schema-ir/postgres-database-schema-node.ts","../src/core/schema-ir/postgres-namespace-schema-node.ts","../src/core/schema-ir/postgres-policy-schema-node.ts","../src/core/schema-ir/postgres-role-schema-node.ts"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresNamespaceSchemaNode } from './postgres-namespace-schema-node';\nimport type { PostgresRoleSchemaNode } from './postgres-role-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresDatabaseSchemaNodeInput {\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n}\n\n/**\n * The root of the Postgres schema-diff tree: one node per database.\n *\n * `id` is the fixed sentinel `'database'` — the root has no siblings and\n * the value is never emitted into migration paths. `isEqualTo` is identity\n * (roots always share the `'database'` id). `children()` yields the namespace\n * nodes followed by the role nodes — both are root-level diff subjects. The\n * differ pairs siblings by `(nodeKind, id)`, so a role and a namespace may\n * share a name without colliding.\n */\nexport class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.database;\n\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n\n  constructor(input: PostgresDatabaseSchemaNodeInput) {\n    super();\n    this.namespaces = Object.freeze({ ...input.namespaces });\n    this.roles = Object.freeze([...input.roles]);\n    this.existingSchemas = Object.freeze([...input.existingSchemas]);\n    this.pgVersion = input.pgVersion;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return 'database';\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [...Object.values(this.namespaces), ...this.roles];\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.database;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresDatabaseSchemaNode {\n    assertNode(node, 'PostgresDatabaseSchemaNode', PostgresDatabaseSchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresNativeEnumSchemaNode } from './postgres-native-enum-schema-node';\nimport type { PostgresTableSchemaNode } from './postgres-table-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresNamespaceSchemaNodeInput {\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  /**\n   * The native-enum diff nodes belonging to this namespace, member values in\n   * `pg_enum.enumsortorder` (declaration) order. The expected\n   * (contract-projected) side attaches each node's `control` (the contract\n   * entity's grade); introspection builds nodes with no `control`.\n   */\n  readonly nativeEnums?: readonly PostgresNativeEnumSchemaNode[];\n}\n\n/**\n * One-per-Postgres-schema diff-tree node. Groups the tables belonging to a\n * single namespace. Per-schema consumers (the relational planner,\n * toSchemaView) read this node's `tables` field structurally via\n * `blindCast`/`SqlSchemaIRNode` — not through a static `SqlSchemaIR`\n * assignment — because `nodeKind` carries this node's own literal\n * (`postgres-namespace`), distinct from `SqlSchemaIR`'s own (`sql-schema`).\n *\n * `id` is the schema name; `isEqualTo` is identity on it; `children()` returns\n * the table nodes plus `nativeEnums`.\n *\n * `nativeEnums` is the diff-tree representation of native enum types the\n * differ pairs — the sole enum carrier, built directly by both sides: the\n * expected (contract-projected) side and introspection alike hand in\n * `PostgresNativeEnumSchemaNode`s.\n */\nexport class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.namespace;\n\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnums: readonly PostgresNativeEnumSchemaNode[];\n\n  constructor(input: PostgresNamespaceSchemaNodeInput) {\n    super();\n    this.schemaName = input.schemaName;\n    this.tables = Object.freeze({ ...input.tables });\n    this.nativeEnums = Object.freeze([...(input.nativeEnums ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.schemaName;\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [...Object.values(this.tables), ...this.nativeEnums];\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresNamespaceSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.namespace;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresNamespaceSchemaNode {\n    assertNode(node, 'PostgresNamespaceSchemaNode', PostgresNamespaceSchemaNode.is);\n  }\n}\n","import type { DiffableNode, SchemaNodeRef } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, defineNonEnumerable, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { RlsPolicyOperation } from '../postgres-rls-policy';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresPolicySchemaNodeInput {\n  /** Full wire name: `<prefix>_<8hex>`. */\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). */\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  /** Sorted role names rendered in `TO <roles>`. */\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   * This policy's table node, plus one entry per role it grants to — each\n   * as the root-anchored chain the differ pairs siblings with. Stamped by\n   * the derivation, which holds the parent (database/namespace) context.\n   * Never compared by `isEqualTo`.\n   */\n  readonly dependsOn?: readonly SchemaNodeRef[];\n}\n\n/**\n * Schema-diff leaf node for a Postgres row-level security policy.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRlsPolicy` contract entities / introspected rows.\n *\n * `id` is the wire name (`<prefix>_<sha256(body)[0..8]>`), so name-equality is\n * body-equality. `isEqualTo` compares names only — never byte-compare predicate\n * bodies, because Postgres reprints them.\n */\nexport class PostgresPolicySchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.policy;\n\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  /** See {@link PostgresPolicySchemaNodeInput.dependsOn}. Non-enumerable so it stays out of JSON and structural equality, matching `SqlColumnIR.codecRef`. */\n  declare readonly dependsOn?: readonly SchemaNodeRef[];\n\n  constructor(input: PostgresPolicySchemaNodeInput) {\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    defineNonEnumerable(this, 'dependsOn', input.dependsOn);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-policy kinds'\n    >(other);\n    PostgresPolicySchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresPolicySchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.policy;\n  }\n\n  static assert(node: SqlSchemaIRNode | undefined): asserts node is PostgresPolicySchemaNode {\n    assertNode(node, 'PostgresPolicySchemaNode', PostgresPolicySchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresRoleSchemaNodeInput {\n  readonly name: string;\n  /**\n   * Namespace coordinate. Roles are cluster-scoped; callers pass\n   * `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`.\n   */\n  readonly namespaceId: string;\n}\n\n/**\n * Schema-diff leaf node for a Postgres database role.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRole` contract entities / introspected rows.\n *\n * Roles are cluster-scoped, so `id` is the bare role name. The differ pairs\n * siblings by `(nodeKind, id)`, so a role and a namespace may share a name\n * (role `public`, schema `public`) without colliding. `isEqualTo` compares\n * ids — name-equality is role-equality for cluster-scoped objects.\n */\nexport class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.role;\n\n  readonly name: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRoleSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-role kinds'\n    >(other);\n    PostgresRoleSchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresRoleSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.role;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode {\n    assertNode(node, 'PostgresRoleSchemaNode', PostgresRoleSchemaNode.is);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"postgres-role-schema-node-DOkim7QI.mjs","names":[],"sources":["../src/core/schema-ir/postgres-database-schema-node.ts","../src/core/schema-ir/postgres-namespace-schema-node.ts","../src/core/schema-ir/postgres-policy-schema-node.ts","../src/core/schema-ir/postgres-role-schema-node.ts"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresNamespaceSchemaNode } from './postgres-namespace-schema-node';\nimport type { PostgresRoleSchemaNode } from './postgres-role-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresDatabaseSchemaNodeInput {\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n}\n\n/**\n * The root of the Postgres schema-diff tree: one node per database.\n *\n * `id` is the fixed sentinel `'database'` — the root has no siblings and\n * the value is never emitted into migration paths. `isEqualTo` is identity\n * (roots always share the `'database'` id). `children()` yields the namespace\n * nodes followed by the role nodes — both are root-level diff subjects. The\n * differ pairs siblings by `(nodeKind, id)`, so a role and a namespace may\n * share a name without colliding.\n */\nexport class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.database;\n\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n\n  constructor(input: PostgresDatabaseSchemaNodeInput) {\n    super();\n    this.namespaces = Object.freeze({ ...input.namespaces });\n    this.roles = Object.freeze([...input.roles]);\n    this.existingSchemas = Object.freeze([...input.existingSchemas]);\n    this.pgVersion = input.pgVersion;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return 'database';\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [...Object.values(this.namespaces), ...this.roles];\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.database;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresDatabaseSchemaNode {\n    assertNode(node, 'PostgresDatabaseSchemaNode', PostgresDatabaseSchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresNativeEnumSchemaNode } from './postgres-native-enum-schema-node';\nimport type { PostgresTableSchemaNode } from './postgres-table-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresNamespaceSchemaNodeInput {\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  /**\n   * The native-enum diff nodes belonging to this namespace, member values in\n   * `pg_enum.enumsortorder` (declaration) order. The expected\n   * (contract-projected) side attaches each node's `control` (the contract\n   * entity's grade); introspection builds nodes with no `control`.\n   */\n  readonly nativeEnums?: readonly PostgresNativeEnumSchemaNode[];\n}\n\n/**\n * One-per-Postgres-schema diff-tree node. Groups the tables belonging to a\n * single namespace. Per-schema consumers (the relational planner,\n * toSchemaView) read this node's `tables` field structurally via\n * `blindCast`/`SqlSchemaIRNode` — not through a static `SqlSchemaIR`\n * assignment — because `nodeKind` carries this node's own literal\n * (`postgres-namespace`), distinct from `SqlSchemaIR`'s own (`sql-schema`).\n *\n * `id` is the schema name; `isEqualTo` is identity on it; `children()` returns\n * the table nodes plus `nativeEnums`.\n *\n * `nativeEnums` is the diff-tree representation of native enum types the\n * differ pairs — the sole enum carrier, built directly by both sides: the\n * expected (contract-projected) side and introspection alike hand in\n * `PostgresNativeEnumSchemaNode`s.\n */\nexport class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.namespace;\n\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnums: readonly PostgresNativeEnumSchemaNode[];\n\n  constructor(input: PostgresNamespaceSchemaNodeInput) {\n    super();\n    this.schemaName = input.schemaName;\n    this.tables = Object.freeze({ ...input.tables });\n    this.nativeEnums = Object.freeze([...(input.nativeEnums ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.schemaName;\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [...Object.values(this.tables), ...this.nativeEnums];\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresNamespaceSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.namespace;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresNamespaceSchemaNode {\n    assertNode(node, 'PostgresNamespaceSchemaNode', PostgresNamespaceSchemaNode.is);\n  }\n}\n","import type { DiffableNode, SchemaNodeRef } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, defineNonEnumerable, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { RlsPolicyOperation } from '../postgres-rls-policy';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresPolicySchemaNodeInput {\n  /** Full wire name: `<prefix>_<8hex>`. */\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). */\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  /** Sorted role names rendered in `TO <roles>`. */\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   * This policy's table node, plus one entry per role it grants to — each\n   * as the root-anchored chain the differ pairs siblings with. Stamped by\n   * the derivation, which holds the parent (database/namespace) context.\n   * Never compared by `isEqualTo`.\n   */\n  readonly dependsOn?: readonly SchemaNodeRef[];\n}\n\n/**\n * Schema-diff leaf node for a Postgres row-level security policy.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRlsPolicy` contract entities / introspected rows.\n *\n * `id` is the wire name (`<prefix>_<sha256(body)[0..8]>`), so name-equality is\n * body-equality. `isEqualTo` compares names only — never byte-compare predicate\n * bodies, because Postgres reprints them.\n */\nexport class PostgresPolicySchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.policy;\n\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  /** See {@link PostgresPolicySchemaNodeInput.dependsOn}. Non-enumerable so it stays out of JSON and structural equality, matching `SqlColumnIR.codecRef`. */\n  declare readonly dependsOn?: readonly SchemaNodeRef[];\n\n  constructor(input: PostgresPolicySchemaNodeInput) {\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    defineNonEnumerable(this, 'dependsOn', input.dependsOn);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-policy kinds'\n    >(other);\n    PostgresPolicySchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresPolicySchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.policy;\n  }\n\n  static assert(node: SqlSchemaIRNode | undefined): asserts node is PostgresPolicySchemaNode {\n    assertNode(node, 'PostgresPolicySchemaNode', PostgresPolicySchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresRoleSchemaNodeInput {\n  readonly name: string;\n  /**\n   * Namespace coordinate. Roles are cluster-scoped; callers pass\n   * `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`.\n   */\n  readonly namespaceId: string;\n}\n\n/**\n * Schema-diff leaf node for a Postgres database role.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRole` contract entities / introspected rows.\n *\n * Roles are cluster-scoped, so `id` is the bare role name. The differ pairs\n * siblings by `(nodeKind, id)`, so a role and a namespace may share a name\n * (role `public`, schema `public`) without colliding. `isEqualTo` compares\n * ids — name-equality is role-equality for cluster-scoped objects.\n */\nexport class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.role;\n\n  readonly name: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRoleSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-role kinds'\n    >(other);\n    PostgresRoleSchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresRoleSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.role;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode {\n    assertNode(node, 'PostgresRoleSchemaNode', PostgresRoleSchemaNode.is);\n  }\n}\n"],"mappings":"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"}

package/dist/{postgres-schema-CTplQZDK.mjs → postgres-schema-DAhXnFac.mjs}

@@ -1,9 +1,9 @@
 import { b as PG_TEXT_CODEC_ID } from "./codec-ids-D3G8K0YM.mjs";
-import { t as PostgresNativeEnum } from "./postgres-native-enum-BwVNf0Ku.mjs";
-import { t as escapeLiteral } from "./sql-utils-B2lzkKfP.mjs";
+import { t as PostgresNativeEnum } from "./postgres-native-enum-DqjHPN11.mjs";
+import { t as escapeLiteral } from "./sql-utils-CuKSscKn.mjs";
 import { TableSource } from "@prisma-next/sql-relational-core/ast";
-import { UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
+import { UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
 import { type } from "arktype";
 import { SqlNamespaceBase, SqlNode } from "@prisma-next/sql-contract/types";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -421,4 +421,4 @@ function postgresCreateNamespace(input) {
 //#endregion
 export { PostgresRlsEnablement as _, nativeEnumEntityKind as a, roleEntityKind as c, PostgresRlsEnablementSchema as d, PostgresRlsPolicySchema as f, PostgresRlsPolicy as g, ROLE_DEFAULT_CONTROL_POLICY as h, postgresCreateNamespace as i, PostgresTableSource as l, PostgresRole as m, PostgresUnboundSchema as n, policyEntityKind as o, PostgresRoleSchema as p, isPostgresSchema as r, rlsEnablementEntityKind as s, PostgresSchema as t, PostgresNativeEnumSchema as u };
 
-//# sourceMappingURL=postgres-schema-CTplQZDK.mjs.map
+//# sourceMappingURL=postgres-schema-DAhXnFac.mjs.map

package/dist/{postgres-schema-CTplQZDK.mjs.map → postgres-schema-DAhXnFac.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-schema-CTplQZDK.mjs","names":[],"sources":["../src/core/postgres-rls-enablement.ts","../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 { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresRlsEnablementInput {\n  /** Name of the table this marker declares RLS-controlled. */\n  readonly tableName: string;\n  /** Namespace coordinate (schema name). Markers are schema-scoped like policies. */\n  readonly namespaceId: string;\n}\n\n/**\n * Postgres contract-IR marker for `@@rls` on a model: the table named here is\n * RLS-controlled (`ENABLE ROW LEVEL SECURITY` is driven by this marker, never\n * by the policy set).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an\n * entity kind, extends `SqlNode`, and is stored in `contract.json` under\n * `entries.rls[tableName]`. Target-only concept — no SQL-family abstract.\n * Frozen at construction via `freezeNode(this)`. The `kind: 'rls'`\n * discriminant is enumerable so it survives JSON serialization; the literal\n * matches the entries key (one-string rule).\n */\nexport class PostgresRlsEnablement extends SqlNode {\n  override readonly kind = 'rls' as const;\n  readonly tableName: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRlsEnablementInput) {\n    super();\n    this.tableName = input.tableName;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n}\n","import { 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 contract-IR class for a row-level security policy (`CREATE POLICY … ON …`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree uses `PostgresPolicySchemaNode` for that role.\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 {\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","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\n/**\n * Roles are referenced by the contract but never owned — the framework\n * issues no `CREATE`/`DROP ROLE`, so a role's effective governance is always\n * `external`: a missing declared role fails verify, an extra live role is\n * tolerated, and the planner emits zero role DDL. `external` is the only\n * value a role's control can ever carry.\n */\nexport const ROLE_DEFAULT_CONTROL_POLICY = 'external';\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   * Defaults to {@link ROLE_DEFAULT_CONTROL_POLICY} when omitted. Roles are\n   * referenced but never owned, so `'external'` is the only allowed value.\n   */\n  readonly control?: 'external';\n}\n\n/**\n * Postgres contract-IR class for a database role (`CREATE ROLE …`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree uses `PostgresRoleSchemaNode` for that 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 *\n * `control` always carries a value (never omitted): it defaults to\n * {@link ROLE_DEFAULT_CONTROL_POLICY} in the constructor, so both a\n * freshly-authored role and one hydrated from an older `contract.json`\n * lacking the field resolve the same way — the control-policy resolver\n * reads it directly off the entity instead of special-casing role issues.\n */\nexport class PostgresRole extends SqlNode {\n  override readonly kind = 'role' as const;\n  readonly name: string;\n  readonly namespaceId: string;\n  readonly control: 'external';\n\n  constructor(input: PostgresRoleInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    this.control = input.control ?? ROLE_DEFAULT_CONTROL_POLICY;\n    freezeNode(this);\n  }\n}\n","import { type } from 'arktype';\n\nexport const PostgresRoleSchema = type({\n  kind: \"'role'\",\n  name: 'string',\n  namespaceId: 'string',\n  'control?': \"'external'\",\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\nexport const PostgresRlsEnablementSchema = type({\n  kind: \"'rls'\",\n  tableName: 'string',\n  namespaceId: 'string',\n});\n\nexport const PostgresNativeEnumSchema = type({\n  kind: \"'postgres-enum'\",\n  typeName: 'string',\n  members: type.string.array().readonly(),\n  'control?': \"'managed' | 'tolerated' | 'external' | 'observed'\",\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 { PostgresNativeEnum, type PostgresNativeEnumInput } from './postgres-native-enum';\nimport { PostgresRlsEnablement, type PostgresRlsEnablementInput } from './postgres-rls-enablement';\nimport { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport {\n  PostgresNativeEnumSchema,\n  PostgresRlsEnablementSchema,\n  PostgresRlsPolicySchema,\n  PostgresRoleSchema,\n} 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\nexport const rlsEnablementEntityKind: EntityKindDescriptor<\n  PostgresRlsEnablementInput,\n  PostgresRlsEnablement\n> = {\n  kind: 'rls',\n  schema: PostgresRlsEnablementSchema,\n  construct: (input) => new PostgresRlsEnablement(input),\n};\n\nexport const nativeEnumEntityKind: EntityKindDescriptor<\n  PostgresNativeEnumInput,\n  PostgresNativeEnum\n> = {\n  kind: 'native_enum',\n  schema: PostgresNativeEnumSchema,\n  construct: (input) => new PostgresNativeEnum(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 { invariant } from '@prisma-next/utils/assertions';\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 {\n  nativeEnumEntityKind,\n  policyEntityKind,\n  rlsEnablementEntityKind,\n  roleEntityKind,\n} from './entity-kinds';\nimport { PostgresNativeEnum } from './postgres-native-enum';\nimport type { PostgresRlsEnablement } from './postgres-rls-enablement';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './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  readonly rls?: Readonly<Record<string, PostgresRlsEnablement>>;\n  readonly native_enum?: Readonly<Record<string, PostgresNativeEnum>>;\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([\n        policyEntityKind,\n        roleEntityKind,\n        rlsEnablementEntityKind,\n        nativeEnumEntityKind,\n      ]),\n      'carry',\n    );\n\n    // A native enum keys under its PHYSICAL type name in storage `entries`\n    // (ADR 221 coordinate `entityName`). The family/authoring layer keys every\n    // block by its author handle, so re-key the `native_enum` slot by each\n    // entity's `typeName` here — target-local Postgres code that already knows\n    // this entity kind. This runs at both authoring and hydration; a serialized\n    // contract's key already equals the `typeName`, so the re-key is idempotent.\n    const nativeEnumSlot = dispatched['native_enum'];\n    if (nativeEnumSlot !== undefined) {\n      const rekeyed: Record<string, unknown> = {};\n      for (const [handle, entity] of Object.entries(nativeEnumSlot)) {\n        const physicalName = PostgresNativeEnum.is(entity) ? entity.typeName : handle;\n        invariant(\n          !Object.hasOwn(rekeyed, physicalName),\n          `PostgresSchema \"${input.id}\": two native_enum entities resolve to the same physical type name \"${physicalName}\". Give them distinct @@map type names.`,\n        );\n        rekeyed[physicalName] = entity;\n      }\n      dispatched['native_enum'] = Object.freeze(rekeyed);\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    const entriesInput: Record<string, Readonly<Record<string, unknown>> | undefined> = {\n      ...withPresence,\n    };\n\n    this.entries = Object.freeze(\n      blindCast<\n        PostgresNamespaceEntries,\n        'composeSqlEntityKinds([policyEntityKind, roleEntityKind, rlsEnablementEntityKind, nativeEnumEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole, rls→PostgresRlsEnablement, native_enum→PostgresNativeEnum descriptors'\n      >(entriesInput),\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  get rls(): Readonly<Record<string, PostgresRlsEnablement>> {\n    return this.entries.rls ?? 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. Native-enum column type names are\n * schema-qualified earlier, at column construction, via the target's\n * `authoring.qualifyColumnType` hook (`postgresQualifyColumnType`), so this\n * factory just materialises the namespace from already-qualified entries.\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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"}
+{"version":3,"file":"postgres-schema-DAhXnFac.mjs","names":[],"sources":["../src/core/postgres-rls-enablement.ts","../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 { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\nexport interface PostgresRlsEnablementInput {\n  /** Name of the table this marker declares RLS-controlled. */\n  readonly tableName: string;\n  /** Namespace coordinate (schema name). Markers are schema-scoped like policies. */\n  readonly namespaceId: string;\n}\n\n/**\n * Postgres contract-IR marker for `@@rls` on a model: the table named here is\n * RLS-controlled (`ENABLE ROW LEVEL SECURITY` is driven by this marker, never\n * by the policy set).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an\n * entity kind, extends `SqlNode`, and is stored in `contract.json` under\n * `entries.rls[tableName]`. Target-only concept — no SQL-family abstract.\n * Frozen at construction via `freezeNode(this)`. The `kind: 'rls'`\n * discriminant is enumerable so it survives JSON serialization; the literal\n * matches the entries key (one-string rule).\n */\nexport class PostgresRlsEnablement extends SqlNode {\n  override readonly kind = 'rls' as const;\n  readonly tableName: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRlsEnablementInput) {\n    super();\n    this.tableName = input.tableName;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n}\n","import { 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 contract-IR class for a row-level security policy (`CREATE POLICY … ON …`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree uses `PostgresPolicySchemaNode` for that role.\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 {\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","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from '@prisma-next/sql-contract/types';\n\n/**\n * Roles are referenced by the contract but never owned — the framework\n * issues no `CREATE`/`DROP ROLE`, so a role's effective governance is always\n * `external`: a missing declared role fails verify, an extra live role is\n * tolerated, and the planner emits zero role DDL. `external` is the only\n * value a role's control can ever carry.\n */\nexport const ROLE_DEFAULT_CONTROL_POLICY = 'external';\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   * Defaults to {@link ROLE_DEFAULT_CONTROL_POLICY} when omitted. Roles are\n   * referenced but never owned, so `'external'` is the only allowed value.\n   */\n  readonly control?: 'external';\n}\n\n/**\n * Postgres contract-IR class for a database role (`CREATE ROLE …`).\n *\n * This is an authored, serialized Contract-IR entity — it is registered as an entity\n * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;\n * the schema-diff tree uses `PostgresRoleSchemaNode` for that 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 *\n * `control` always carries a value (never omitted): it defaults to\n * {@link ROLE_DEFAULT_CONTROL_POLICY} in the constructor, so both a\n * freshly-authored role and one hydrated from an older `contract.json`\n * lacking the field resolve the same way — the control-policy resolver\n * reads it directly off the entity instead of special-casing role issues.\n */\nexport class PostgresRole extends SqlNode {\n  override readonly kind = 'role' as const;\n  readonly name: string;\n  readonly namespaceId: string;\n  readonly control: 'external';\n\n  constructor(input: PostgresRoleInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    this.control = input.control ?? ROLE_DEFAULT_CONTROL_POLICY;\n    freezeNode(this);\n  }\n}\n","import { type } from 'arktype';\n\nexport const PostgresRoleSchema = type({\n  kind: \"'role'\",\n  name: 'string',\n  namespaceId: 'string',\n  'control?': \"'external'\",\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\nexport const PostgresRlsEnablementSchema = type({\n  kind: \"'rls'\",\n  tableName: 'string',\n  namespaceId: 'string',\n});\n\nexport const PostgresNativeEnumSchema = type({\n  kind: \"'postgres-enum'\",\n  typeName: 'string',\n  members: type.string.array().readonly(),\n  'control?': \"'managed' | 'tolerated' | 'external' | 'observed'\",\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 { PostgresNativeEnum, type PostgresNativeEnumInput } from './postgres-native-enum';\nimport { PostgresRlsEnablement, type PostgresRlsEnablementInput } from './postgres-rls-enablement';\nimport { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport {\n  PostgresNativeEnumSchema,\n  PostgresRlsEnablementSchema,\n  PostgresRlsPolicySchema,\n  PostgresRoleSchema,\n} 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\nexport const rlsEnablementEntityKind: EntityKindDescriptor<\n  PostgresRlsEnablementInput,\n  PostgresRlsEnablement\n> = {\n  kind: 'rls',\n  schema: PostgresRlsEnablementSchema,\n  construct: (input) => new PostgresRlsEnablement(input),\n};\n\nexport const nativeEnumEntityKind: EntityKindDescriptor<\n  PostgresNativeEnumInput,\n  PostgresNativeEnum\n> = {\n  kind: 'native_enum',\n  schema: PostgresNativeEnumSchema,\n  construct: (input) => new PostgresNativeEnum(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 { invariant } from '@prisma-next/utils/assertions';\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 {\n  nativeEnumEntityKind,\n  policyEntityKind,\n  rlsEnablementEntityKind,\n  roleEntityKind,\n} from './entity-kinds';\nimport { PostgresNativeEnum } from './postgres-native-enum';\nimport type { PostgresRlsEnablement } from './postgres-rls-enablement';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './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  readonly rls?: Readonly<Record<string, PostgresRlsEnablement>>;\n  readonly native_enum?: Readonly<Record<string, PostgresNativeEnum>>;\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([\n        policyEntityKind,\n        roleEntityKind,\n        rlsEnablementEntityKind,\n        nativeEnumEntityKind,\n      ]),\n      'carry',\n    );\n\n    // A native enum keys under its PHYSICAL type name in storage `entries`\n    // (ADR 221 coordinate `entityName`). The family/authoring layer keys every\n    // block by its author handle, so re-key the `native_enum` slot by each\n    // entity's `typeName` here — target-local Postgres code that already knows\n    // this entity kind. This runs at both authoring and hydration; a serialized\n    // contract's key already equals the `typeName`, so the re-key is idempotent.\n    const nativeEnumSlot = dispatched['native_enum'];\n    if (nativeEnumSlot !== undefined) {\n      const rekeyed: Record<string, unknown> = {};\n      for (const [handle, entity] of Object.entries(nativeEnumSlot)) {\n        const physicalName = PostgresNativeEnum.is(entity) ? entity.typeName : handle;\n        invariant(\n          !Object.hasOwn(rekeyed, physicalName),\n          `PostgresSchema \"${input.id}\": two native_enum entities resolve to the same physical type name \"${physicalName}\". Give them distinct @@map type names.`,\n        );\n        rekeyed[physicalName] = entity;\n      }\n      dispatched['native_enum'] = Object.freeze(rekeyed);\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    const entriesInput: Record<string, Readonly<Record<string, unknown>> | undefined> = {\n      ...withPresence,\n    };\n\n    this.entries = Object.freeze(\n      blindCast<\n        PostgresNamespaceEntries,\n        'composeSqlEntityKinds([policyEntityKind, roleEntityKind, rlsEnablementEntityKind, nativeEnumEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole, rls→PostgresRlsEnablement, native_enum→PostgresNativeEnum descriptors'\n      >(entriesInput),\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  get rls(): Readonly<Record<string, PostgresRlsEnablement>> {\n    return this.entries.rls ?? 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. Native-enum column type names are\n * schema-qualified earlier, at column construction, via the target's\n * `authoring.qualifyColumnType` hook (`postgresQualifyColumnType`), so this\n * factory just materialises the namespace from already-qualified entries.\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-table-schema-node-D6LvInCe.mjs → postgres-table-schema-node-DXzwiu16.mjs}

@@ -1,5 +1,5 @@
-import { freezeNode } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
+import { freezeNode } from "@prisma-next/framework-components/ir";
 import { PrimaryKey, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlUniqueIR, assertNode, relationalNodeEntityKind, relationalNodeGranularity } from "@prisma-next/sql-schema-ir/types";
 //#region src/core/schema-ir/schema-node-kinds.ts
 /**
@@ -213,4 +213,4 @@ var PostgresTableSchemaNode = class PostgresTableSchemaNode extends SqlSchemaIRN
 //#endregion
 export { postgresDiffSubjectGranularity as a, postgresDiffSubjectEntityKind as i, PostgresNativeEnumSchemaNode as n, postgresNodeEntityKind as o, PostgresSchemaNodeKind as r, PostgresTableSchemaNode as t };
 
-//# sourceMappingURL=postgres-table-schema-node-D6LvInCe.mjs.map
+//# sourceMappingURL=postgres-table-schema-node-DXzwiu16.mjs.map

package/dist/{postgres-table-schema-node-D6LvInCe.mjs.map → postgres-table-schema-node-DXzwiu16.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"postgres-table-schema-node-D6LvInCe.mjs","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts","../src/core/schema-ir/postgres-native-enum-schema-node.ts","../src/core/schema-ir/postgres-table-schema-node.ts"],"sourcesContent":["import type {\n  DiffableNode,\n  DiffSubjectGranularity,\n} from '@prisma-next/framework-components/control';\nimport {\n  relationalNodeEntityKind,\n  relationalNodeGranularity,\n  type SqlSchemaIRNode,\n} from '@prisma-next/sql-schema-ir/types';\n\n/**\n * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements\n * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`\n * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)\n * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node\n * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).\n */\nexport type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;\n\n/**\n * The `nodeKind` discriminant for each Postgres schema-diff node. Each node\n * carries a unique value; the static `is`/`assert` guards compare against these\n * identifiers rather than spelling the string inline or using `instanceof`. The\n * field is an enumerable own property carried on every node instance.\n */\nexport const PostgresSchemaNodeKind = {\n  database: 'postgres-database',\n  namespace: 'postgres-namespace',\n  table: 'postgres-table',\n  policy: 'postgres-policy',\n  role: 'postgres-role',\n  nativeEnum: 'postgres-native-enum',\n} as const;\n\nexport type PostgresSchemaNodeKind =\n  (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];\n\n/**\n * The one real map from a Postgres-specific `nodeKind` to the\n * framework-neutral {@link DiffSubjectGranularity} its diff issues carry —\n * resolution is by `nodeKind` equality against this map, never a\n * `nodeKind`-suffix string match and never anything stamped on the node.\n */\nconst POSTGRES_NODE_GRANULARITY: Readonly<Record<PostgresSchemaNodeKind, DiffSubjectGranularity>> =\n  {\n    [PostgresSchemaNodeKind.database]: 'structural',\n    [PostgresSchemaNodeKind.namespace]: 'namespace',\n    [PostgresSchemaNodeKind.table]: 'entity',\n    // A policy set is owned by the managed table it attaches to; a role is\n    // referenced by the contract but not owned (the framework names it in a\n    // policy but never owns the cluster's role list). Both classify as\n    // `structural`. The asymmetry for roles — a missing declared one fails, an\n    // undeclared live one is tolerated unconditionally — comes from the\n    // control policy the diff resolves a role issue against (`external`),\n    // not from the granularity.\n    [PostgresSchemaNodeKind.policy]: 'structural',\n    [PostgresSchemaNodeKind.role]: 'structural',\n    [PostgresSchemaNodeKind.nativeEnum]: 'entity',\n  };\n\nfunction isPostgresSchemaNodeKind(nodeKind: string): nodeKind is PostgresSchemaNodeKind {\n  return Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);\n}\n\n/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */\nexport function postgresNodeGranularity(nodeKind: PostgresSchemaNodeKind): DiffSubjectGranularity {\n  return POSTGRES_NODE_GRANULARITY[nodeKind];\n}\n\n/**\n * The subject granularity for any node kind that appears in a Postgres diff\n * tree — the tree mixes Postgres-specific kinds (database/namespace/table/\n * policy/role) with the relational leaf kinds (columns, constraints, indexes,\n * …), so this dispatches to whichever family/target map owns the kind. Called\n * on demand by consumers (the family verdict, the framework aggregate's\n * unclaimed-elements sweep, via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability) — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectGranularity(nodeKind: string): DiffSubjectGranularity {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeGranularity(nodeKind)\n    : relationalNodeGranularity(nodeKind);\n}\n\n/**\n * The map from a Postgres-specific `nodeKind` to its storage `entityKind` — the\n * same vocabulary the contract storage's `entries` dictionary keys use. The\n * whole-table and native-enum kinds each have an entity of their own;\n * database/namespace/policy/role nodes map to nothing here (a namespace is\n * addressed by id, not by an `entries` kind; policies and roles are\n * structural, never a sibling space's unclaimed entity).\n *\n * The native enum keys under its PHYSICAL type name in `entries.native_enum`\n * (ADR 221), so its diff node's `typeName` addresses the entity on the generic\n * coordinate directly — no by-type-name walk needed. This lets the framework's\n * unclaimed-elements sweep classify enum ownership the same coordinate way it\n * classifies tables.\n */\nconst POSTGRES_NODE_ENTITY_KIND: Partial<Readonly<Record<PostgresSchemaNodeKind, string>>> = {\n  [PostgresSchemaNodeKind.table]: 'table',\n  [PostgresSchemaNodeKind.nativeEnum]: 'native_enum',\n};\n\n/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */\nexport function postgresNodeEntityKind(nodeKind: PostgresSchemaNodeKind): string | undefined {\n  return POSTGRES_NODE_ENTITY_KIND[nodeKind];\n}\n\n/**\n * The storage `entityKind` for any node kind that appears in a Postgres diff\n * tree — sibling of {@link postgresDiffSubjectGranularity}, dispatching the\n * same way to whichever family/target map owns the kind. Called on demand by\n * the framework aggregate's unclaimed-elements sweep via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectEntityKind(nodeKind: string): string | undefined {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeEntityKind(nodeKind)\n    : relationalNodeEntityKind(nodeKind);\n}\n","import type { ControlPolicy } from '@prisma-next/contract/types';\nimport type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresNativeEnumSchemaNodeInput {\n  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */\n  readonly typeName: string;\n  /** The owning DDL schema name — enum types are schema-scoped. */\n  readonly namespaceId: string;\n  /** Member values in declaration (`pg_enum.enumsortorder`) order. */\n  readonly members: readonly string[];\n  /** The contract entity's control grade — expected-side nodes only. */\n  readonly control?: ControlPolicy;\n}\n\n/**\n * Schema-diff leaf node for a native Postgres enum type.\n *\n * This is a derived, transient node walked by the differ — it is NEVER\n * serialized. Both sides derive it on the namespace node: the expected side\n * from the contract's hydrated `entries.native_enum` entities, the actual\n * side from the adapter's introspected `nativeEnums`.\n *\n * Enum types are schema-scoped, so identity is (namespace, type name): the\n * namespace coordinate comes from tree position (the differ pairs enum nodes\n * only inside an already-paired namespace) and `id` carries the type name,\n * prefixed with the entries-kind vocabulary (`native_enum:<typeName>`) so it\n * cannot collide with a sibling table of the same name — the same\n * sibling-prefix convention relational column nodes use (`column:<name>`).\n *\n * `isEqualTo` compares members POSITIONALLY — `['a','b'] ≠ ['b','a']` —\n * because Postgres enum sort order is semantic. `control` is contract\n * metadata, not database state, and does not participate in equality.\n */\nexport class PostgresNativeEnumSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.nativeEnum;\n\n  readonly typeName: string;\n  readonly namespaceId: string;\n  readonly members: readonly string[];\n  declare readonly control?: ControlPolicy;\n\n  constructor(input: PostgresNativeEnumSchemaNodeInput) {\n    super();\n    this.typeName = input.typeName;\n    this.namespaceId = input.namespaceId;\n    this.members = Object.freeze([...input.members]);\n    if (input.control !== undefined) this.control = input.control;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return `native_enum:${this.typeName}`;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-enum kinds'\n    >(other);\n    PostgresNativeEnumSchemaNode.assert(node);\n    return (\n      this.typeName === node.typeName &&\n      this.members.length === node.members.length &&\n      this.members.every((member, index) => member === node.members[index])\n    );\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresNativeEnumSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.nativeEnum;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresNativeEnumSchemaNode {\n    assertNode(node, 'PostgresNativeEnumSchemaNode', PostgresNativeEnumSchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  assertNode,\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 { blindCast } from '@prisma-next/utils/casts';\nimport type { PostgresPolicySchemaNode } from './postgres-policy-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresTableSchemaNodeInput extends SqlTableIRInput {\n  readonly policies?: readonly PostgresPolicySchemaNode[];\n  /**\n   * Whether row-level security is enabled on this table. Expected side:\n   * stamped from the contract's `entries.rls` marker (never from the\n   * policy set). Actual side: stamped from `pg_class.relrowsecurity` at\n   * introspection. Required with no default so every construction site\n   * supplies a deliberate value.\n   */\n  readonly rlsEnabled: boolean;\n}\n\n/**\n * Postgres-specific table schema-diff node. Carries all `SqlTableIR` fields\n * plus `policies`, 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.\n *\n * `id` is the table name. `isEqualTo` compares id + `rlsEnabled` — the\n * table's one own diffable attribute; all other structural drift is\n * expressed by its children. `children()` returns every column, the primary\n * key (when present), every foreign key, unique, index, and check constraint,\n * plus the policy nodes — one flat list, so a drifted column and a drifted\n * policy are both reported by the same walk. Order is deterministic (object\n * key order for columns, array order for the rest) so two structurally equal\n * tables always produce the same child list.\n */\nexport class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.table;\n\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 policies: readonly PostgresPolicySchemaNode[];\n  readonly rlsEnabled: boolean;\n\n  constructor(input: PostgresTableSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.rlsEnabled = input.rlsEnabled;\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.policies = Object.freeze([...(input.policies ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  /**\n   * Equal iff the ids (names) match AND `rlsEnabled` matches — the table's\n   * one own attribute in the diff; all other structural drift is expressed\n   * by children. A paired `not-equal` therefore always means enablement\n   * drift, which the planner maps to ENABLE/DISABLE ROW LEVEL SECURITY.\n   */\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode'\n    >(other);\n    PostgresTableSchemaNode.assert(node);\n    return this.id === node.id && this.rlsEnabled === node.rlsEnabled;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [\n      ...Object.values(this.columns),\n      ...(this.primaryKey ? [this.primaryKey] : []),\n      ...this.foreignKeys,\n      ...this.uniques,\n      ...this.indexes,\n      ...(this.checks ?? []),\n      ...this.policies,\n    ];\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.table;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode {\n    assertNode(node, 'PostgresTableSchemaNode', PostgresTableSchemaNode.is);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"postgres-table-schema-node-DXzwiu16.mjs","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts","../src/core/schema-ir/postgres-native-enum-schema-node.ts","../src/core/schema-ir/postgres-table-schema-node.ts"],"sourcesContent":["import type {\n  DiffableNode,\n  DiffSubjectGranularity,\n} from '@prisma-next/framework-components/control';\nimport {\n  relationalNodeEntityKind,\n  relationalNodeGranularity,\n  type SqlSchemaIRNode,\n} from '@prisma-next/sql-schema-ir/types';\n\n/**\n * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements\n * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`\n * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)\n * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node\n * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).\n */\nexport type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;\n\n/**\n * The `nodeKind` discriminant for each Postgres schema-diff node. Each node\n * carries a unique value; the static `is`/`assert` guards compare against these\n * identifiers rather than spelling the string inline or using `instanceof`. The\n * field is an enumerable own property carried on every node instance.\n */\nexport const PostgresSchemaNodeKind = {\n  database: 'postgres-database',\n  namespace: 'postgres-namespace',\n  table: 'postgres-table',\n  policy: 'postgres-policy',\n  role: 'postgres-role',\n  nativeEnum: 'postgres-native-enum',\n} as const;\n\nexport type PostgresSchemaNodeKind =\n  (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];\n\n/**\n * The one real map from a Postgres-specific `nodeKind` to the\n * framework-neutral {@link DiffSubjectGranularity} its diff issues carry —\n * resolution is by `nodeKind` equality against this map, never a\n * `nodeKind`-suffix string match and never anything stamped on the node.\n */\nconst POSTGRES_NODE_GRANULARITY: Readonly<Record<PostgresSchemaNodeKind, DiffSubjectGranularity>> =\n  {\n    [PostgresSchemaNodeKind.database]: 'structural',\n    [PostgresSchemaNodeKind.namespace]: 'namespace',\n    [PostgresSchemaNodeKind.table]: 'entity',\n    // A policy set is owned by the managed table it attaches to; a role is\n    // referenced by the contract but not owned (the framework names it in a\n    // policy but never owns the cluster's role list). Both classify as\n    // `structural`. The asymmetry for roles — a missing declared one fails, an\n    // undeclared live one is tolerated unconditionally — comes from the\n    // control policy the diff resolves a role issue against (`external`),\n    // not from the granularity.\n    [PostgresSchemaNodeKind.policy]: 'structural',\n    [PostgresSchemaNodeKind.role]: 'structural',\n    [PostgresSchemaNodeKind.nativeEnum]: 'entity',\n  };\n\nfunction isPostgresSchemaNodeKind(nodeKind: string): nodeKind is PostgresSchemaNodeKind {\n  return Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);\n}\n\n/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */\nexport function postgresNodeGranularity(nodeKind: PostgresSchemaNodeKind): DiffSubjectGranularity {\n  return POSTGRES_NODE_GRANULARITY[nodeKind];\n}\n\n/**\n * The subject granularity for any node kind that appears in a Postgres diff\n * tree — the tree mixes Postgres-specific kinds (database/namespace/table/\n * policy/role) with the relational leaf kinds (columns, constraints, indexes,\n * …), so this dispatches to whichever family/target map owns the kind. Called\n * on demand by consumers (the family verdict, the framework aggregate's\n * unclaimed-elements sweep, via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability) — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectGranularity(nodeKind: string): DiffSubjectGranularity {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeGranularity(nodeKind)\n    : relationalNodeGranularity(nodeKind);\n}\n\n/**\n * The map from a Postgres-specific `nodeKind` to its storage `entityKind` — the\n * same vocabulary the contract storage's `entries` dictionary keys use. The\n * whole-table and native-enum kinds each have an entity of their own;\n * database/namespace/policy/role nodes map to nothing here (a namespace is\n * addressed by id, not by an `entries` kind; policies and roles are\n * structural, never a sibling space's unclaimed entity).\n *\n * The native enum keys under its PHYSICAL type name in `entries.native_enum`\n * (ADR 221), so its diff node's `typeName` addresses the entity on the generic\n * coordinate directly — no by-type-name walk needed. This lets the framework's\n * unclaimed-elements sweep classify enum ownership the same coordinate way it\n * classifies tables.\n */\nconst POSTGRES_NODE_ENTITY_KIND: Partial<Readonly<Record<PostgresSchemaNodeKind, string>>> = {\n  [PostgresSchemaNodeKind.table]: 'table',\n  [PostgresSchemaNodeKind.nativeEnum]: 'native_enum',\n};\n\n/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */\nexport function postgresNodeEntityKind(nodeKind: PostgresSchemaNodeKind): string | undefined {\n  return POSTGRES_NODE_ENTITY_KIND[nodeKind];\n}\n\n/**\n * The storage `entityKind` for any node kind that appears in a Postgres diff\n * tree — sibling of {@link postgresDiffSubjectGranularity}, dispatching the\n * same way to whichever family/target map owns the kind. Called on demand by\n * the framework aggregate's unclaimed-elements sweep via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectEntityKind(nodeKind: string): string | undefined {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeEntityKind(nodeKind)\n    : relationalNodeEntityKind(nodeKind);\n}\n","import type { ControlPolicy } from '@prisma-next/contract/types';\nimport type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresNativeEnumSchemaNodeInput {\n  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */\n  readonly typeName: string;\n  /** The owning DDL schema name — enum types are schema-scoped. */\n  readonly namespaceId: string;\n  /** Member values in declaration (`pg_enum.enumsortorder`) order. */\n  readonly members: readonly string[];\n  /** The contract entity's control grade — expected-side nodes only. */\n  readonly control?: ControlPolicy;\n}\n\n/**\n * Schema-diff leaf node for a native Postgres enum type.\n *\n * This is a derived, transient node walked by the differ — it is NEVER\n * serialized. Both sides derive it on the namespace node: the expected side\n * from the contract's hydrated `entries.native_enum` entities, the actual\n * side from the adapter's introspected `nativeEnums`.\n *\n * Enum types are schema-scoped, so identity is (namespace, type name): the\n * namespace coordinate comes from tree position (the differ pairs enum nodes\n * only inside an already-paired namespace) and `id` carries the type name,\n * prefixed with the entries-kind vocabulary (`native_enum:<typeName>`) so it\n * cannot collide with a sibling table of the same name — the same\n * sibling-prefix convention relational column nodes use (`column:<name>`).\n *\n * `isEqualTo` compares members POSITIONALLY — `['a','b'] ≠ ['b','a']` —\n * because Postgres enum sort order is semantic. `control` is contract\n * metadata, not database state, and does not participate in equality.\n */\nexport class PostgresNativeEnumSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.nativeEnum;\n\n  readonly typeName: string;\n  readonly namespaceId: string;\n  readonly members: readonly string[];\n  declare readonly control?: ControlPolicy;\n\n  constructor(input: PostgresNativeEnumSchemaNodeInput) {\n    super();\n    this.typeName = input.typeName;\n    this.namespaceId = input.namespaceId;\n    this.members = Object.freeze([...input.members]);\n    if (input.control !== undefined) this.control = input.control;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return `native_enum:${this.typeName}`;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-enum kinds'\n    >(other);\n    PostgresNativeEnumSchemaNode.assert(node);\n    return (\n      this.typeName === node.typeName &&\n      this.members.length === node.members.length &&\n      this.members.every((member, index) => member === node.members[index])\n    );\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresNativeEnumSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.nativeEnum;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresNativeEnumSchemaNode {\n    assertNode(node, 'PostgresNativeEnumSchemaNode', PostgresNativeEnumSchemaNode.is);\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  assertNode,\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 { blindCast } from '@prisma-next/utils/casts';\nimport type { PostgresPolicySchemaNode } from './postgres-policy-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresTableSchemaNodeInput extends SqlTableIRInput {\n  readonly policies?: readonly PostgresPolicySchemaNode[];\n  /**\n   * Whether row-level security is enabled on this table. Expected side:\n   * stamped from the contract's `entries.rls` marker (never from the\n   * policy set). Actual side: stamped from `pg_class.relrowsecurity` at\n   * introspection. Required with no default so every construction site\n   * supplies a deliberate value.\n   */\n  readonly rlsEnabled: boolean;\n}\n\n/**\n * Postgres-specific table schema-diff node. Carries all `SqlTableIR` fields\n * plus `policies`, 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.\n *\n * `id` is the table name. `isEqualTo` compares id + `rlsEnabled` — the\n * table's one own diffable attribute; all other structural drift is\n * expressed by its children. `children()` returns every column, the primary\n * key (when present), every foreign key, unique, index, and check constraint,\n * plus the policy nodes — one flat list, so a drifted column and a drifted\n * policy are both reported by the same walk. Order is deterministic (object\n * key order for columns, array order for the rest) so two structurally equal\n * tables always produce the same child list.\n */\nexport class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.table;\n\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 policies: readonly PostgresPolicySchemaNode[];\n  readonly rlsEnabled: boolean;\n\n  constructor(input: PostgresTableSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.rlsEnabled = input.rlsEnabled;\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.policies = Object.freeze([...(input.policies ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  /**\n   * Equal iff the ids (names) match AND `rlsEnabled` matches — the table's\n   * one own attribute in the diff; all other structural drift is expressed\n   * by children. A paired `not-equal` therefore always means enablement\n   * drift, which the planner maps to ENABLE/DISABLE ROW LEVEL SECURITY.\n   */\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode'\n    >(other);\n    PostgresTableSchemaNode.assert(node);\n    return this.id === node.id && this.rlsEnabled === node.rlsEnabled;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [\n      ...Object.values(this.columns),\n      ...(this.primaryKey ? [this.primaryKey] : []),\n      ...this.foreignKeys,\n      ...this.uniques,\n      ...this.indexes,\n      ...(this.checks ?? []),\n      ...this.policies,\n    ];\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.table;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode {\n    assertNode(node, 'PostgresTableSchemaNode', PostgresTableSchemaNode.is);\n  }\n}\n"],"mappings":"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"}

package/dist/{render-ops-TcY9XEkz.mjs → render-ops-DIjVRr1-.mjs}

@@ -1,4 +1,4 @@
-import { n as postgresError } from "./errors-DBSNx7EJ.mjs";
+import { n as postgresError } from "./errors-l1usFTuz.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { isThenable } from "@prisma-next/utils/promise";
 //#region src/core/migrations/render-ops.ts
@@ -31,4 +31,4 @@ function renderOps(calls, lowerer) {
 //#endregion
 export { renderOps as t };
 
-//# sourceMappingURL=render-ops-TcY9XEkz.mjs.map
+//# sourceMappingURL=render-ops-DIjVRr1-.mjs.map

package/dist/{render-ops-TcY9XEkz.mjs.map → render-ops-DIjVRr1-.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"render-ops-TcY9XEkz.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type {\n  MigrationPlanOperation,\n  OpFactoryCall,\n} from '@prisma-next/framework-components/control';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { isThenable } from '@prisma-next/utils/promise';\nimport { postgresError } from '../errors';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(op: MigrationPlanOperation, callFactoryName: string): asserts op is Op {\n  const targetId = blindCast<\n    { target?: { id?: string } },\n    'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'\n  >(op).target?.id;\n  if (targetId !== 'postgres') {\n    throw postgresError(\n      'MIGRATION.TARGET_MISMATCH',\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n      { meta: { opId: op.id, targetId: String(targetId), factoryName: callFactoryName } },\n    );\n  }\n}\n\nexport function renderOps(\n  calls: readonly OpFactoryCall[],\n  lowerer?: ExecuteRequestLowerer,\n): (Op | Promise<Op>)[] {\n  return calls.map((c) => {\n    const opOrPromise = blindCast<\n      { toOp(lowerer?: ExecuteRequestLowerer): Op | Promise<Op> },\n      'PG OpFactoryCall.toOp accepts an optional ExecuteRequestLowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'\n    >(c).toOp(lowerer);\n    if (isThenable(opOrPromise)) {\n      return opOrPromise.then((op) => {\n        assertPostgresOp(op, c.factoryName);\n        return op;\n      });\n    }\n    assertPostgresOp(opOrPromise, c.factoryName);\n    return opOrPromise;\n  });\n}\n"],"mappings":";;;;;;;;;;;AAoBA,SAAS,iBAAiB,IAA4B,iBAA2C;CAC/F,MAAM,WAAW,UAGf,EAAE,CAAC,CAAC,QAAQ;CACd,IAAI,aAAa,YACf,MAAM,cACJ,6BACA,sDAAsD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,4HAC9H,EAAE,MAAM;EAAE,MAAM,GAAG;EAAI,UAAU,OAAO,QAAQ;EAAG,aAAa;CAAgB,EAAE,CACpF;AAEJ;AAEA,SAAgB,UACd,OACA,SACsB;CACtB,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,cAAc,UAGlB,CAAC,CAAC,CAAC,KAAK,OAAO;EACjB,IAAI,WAAW,WAAW,GACxB,OAAO,YAAY,MAAM,OAAO;GAC9B,iBAAiB,IAAI,EAAE,WAAW;GAClC,OAAO;EACT,CAAC;EAEH,iBAAiB,aAAa,EAAE,WAAW;EAC3C,OAAO;CACT,CAAC;AACH"}
+{"version":3,"file":"render-ops-DIjVRr1-.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';\nimport type {\n  MigrationPlanOperation,\n  OpFactoryCall,\n} from '@prisma-next/framework-components/control';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { isThenable } from '@prisma-next/utils/promise';\nimport { postgresError } from '../errors';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(op: MigrationPlanOperation, callFactoryName: string): asserts op is Op {\n  const targetId = blindCast<\n    { target?: { id?: string } },\n    'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'\n  >(op).target?.id;\n  if (targetId !== 'postgres') {\n    throw postgresError(\n      'MIGRATION.TARGET_MISMATCH',\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n      { meta: { opId: op.id, targetId: String(targetId), factoryName: callFactoryName } },\n    );\n  }\n}\n\nexport function renderOps(\n  calls: readonly OpFactoryCall[],\n  lowerer?: ExecuteRequestLowerer,\n): (Op | Promise<Op>)[] {\n  return calls.map((c) => {\n    const opOrPromise = blindCast<\n      { toOp(lowerer?: ExecuteRequestLowerer): Op | Promise<Op> },\n      'PG OpFactoryCall.toOp accepts an optional ExecuteRequestLowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'\n    >(c).toOp(lowerer);\n    if (isThenable(opOrPromise)) {\n      return opOrPromise.then((op) => {\n        assertPostgresOp(op, c.factoryName);\n        return op;\n      });\n    }\n    assertPostgresOp(opOrPromise, c.factoryName);\n    return opOrPromise;\n  });\n}\n"],"mappings":";;;;;;;;;;;AAoBA,SAAS,iBAAiB,IAA4B,iBAA2C;CAC/F,MAAM,WAAW,UAGf,EAAE,CAAC,CAAC,QAAQ;CACd,IAAI,aAAa,YACf,MAAM,cACJ,6BACA,sDAAsD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,4HAC9H,EAAE,MAAM;EAAE,MAAM,GAAG;EAAI,UAAU,OAAO,QAAQ;EAAG,aAAa;CAAgB,EAAE,CACpF;AAEJ;AAEA,SAAgB,UACd,OACA,SACsB;CACtB,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,cAAc,UAGlB,CAAC,CAAC,CAAC,KAAK,OAAO;EACjB,IAAI,WAAW,WAAW,GACxB,OAAO,YAAY,MAAM,OAAO;GAC9B,iBAAiB,IAAI,EAAE,WAAW;GAClC,OAAO;EACT,CAAC;EAEH,iBAAiB,aAAa,EAAE,WAAW;EAC3C,OAAO;CACT,CAAC;AACH"}

package/dist/render-ops.mjs

@@ -1,2 +1,2 @@
-import { t as renderOps } from "./render-ops-TcY9XEkz.mjs";
+import { t as renderOps } from "./render-ops-DIjVRr1-.mjs";
 export { renderOps };

package/dist/{resolve-ddl-schema-BAsJEKW8.mjs → resolve-ddl-schema-nTvL_9Nq.mjs}

@@ -1,5 +1,5 @@
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86.mjs";
-import { r as isPostgresSchema } from "./postgres-schema-CTplQZDK.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-DAhXnFac.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 //#region src/core/migrations/resolve-ddl-schema.ts
 /**
@@ -19,4 +19,4 @@ function resolveDdlSchemaForNamespaceStorage(storage, namespaceId) {
 //#endregion
 export { resolveDdlSchemaForNamespaceStorage as t };
 
-//# sourceMappingURL=resolve-ddl-schema-BAsJEKW8.mjs.map
+//# sourceMappingURL=resolve-ddl-schema-nTvL_9Nq.mjs.map

package/dist/{resolve-ddl-schema-BAsJEKW8.mjs.map → resolve-ddl-schema-nTvL_9Nq.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"resolve-ddl-schema-BAsJEKW8.mjs","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Given the contract's storage and a namespace id, returns the live Postgres\n * DDL schema name that namespace maps to. A named Postgres namespace dispatches\n * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to\n * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a\n * bare object payload (used by some tests) falls back to the namespace id\n * itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return DEFAULT_NAMESPACE_ID;\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,oCACd,SACA,aACQ;CACR,IAAI,gBAAgB,sBAClB,OAAO;CAET,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}
+{"version":3,"file":"resolve-ddl-schema-nTvL_9Nq.mjs","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Given the contract's storage and a namespace id, returns the live Postgres\n * DDL schema name that namespace maps to. A named Postgres namespace dispatches\n * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to\n * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a\n * bare object payload (used by some tests) falls back to the namespace id\n * itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return DEFAULT_NAMESPACE_ID;\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,oCACd,SACA,aACQ;CACR,IAAI,gBAAgB,sBAClB,OAAO;CAET,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
 import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-UwYdV8fD.mjs";
-import { n as PostgresContractSerializer, t as PostgresContractView } from "./postgres-contract-view-BeIEyZfD.mjs";
+import { n as PostgresContractSerializer, t as PostgresContractView } from "./postgres-contract-view-v-zxqBtj.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.mjs

@@ -1,2 +1,2 @@
-import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-BAsJEKW8.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-nTvL_9Nq.mjs";
 export { resolveDdlSchemaForNamespaceStorage };