@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/render-typescript-Cw3lFO28-Cx0lXWmv.mjs

@@ -0,0 +1,117 @@
+import { contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier } from "@prisma/orm-framework/components/control";
+import { renderImports } from "@prisma/orm-framework/ts-render";
+import { resolveRequirementSpecifiers } from "@prisma/orm-framework/components/emission";
+import { detectScaffoldRuntime, shebangLineFor } from "@prisma/orm-toolchain/migration-tools/migration-ts";
+//#region ../../../3-targets/3-targets/postgres/dist/render-typescript-Cw3lFO28.mjs
+/**
+* Polymorphic TypeScript emitter for the Postgres migration IR.
+*
+* Each `OpFactoryCall` renders itself via `renderTypeScript()` and
+* declares its own `importRequirements()`; this file just composes the module
+* source around those contributions. The design mirrors the Mongo target's
+* `render-typescript.ts` deliberately — byte-for-byte alignment isn't required
+* (different factory module specifiers, different base-class name) but the
+* shape is, so future consolidation to a framework-level helper is mechanical.
+*/
+/**
+* Always-present base imports for the rendered scaffold. Both come from
+* `@internal/postgres/migration` so an authored Postgres
+* `migration.ts` only needs a single dependency for its base class and
+* its CLI entrypoint:
+*
+* - `Migration` — the facade re-export fixes the `SqlMigration`
+*   generic to `PostgresPlanTargetDetails` and the abstract `targetId`
+*   to `'postgres'`, so user-authored migrations don't need to thread
+*   target-details or redeclare `targetId`.
+* - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from
+*   `@internal/cli/migration-cli`. Loads `prisma-next.config.ts`,
+*   assembles a `ControlStack`, and instantiates the migration class.
+*   The migration file owns this dependency directly: pulling CLI
+*   machinery in at script run time is acceptable because the script's
+*   whole purpose is to be invoked from the project that owns the
+*   config.
+*/
+const BASE_IMPORTS = [{
+	moduleSpecifier: "@internal/postgres/migration",
+	symbol: "Migration"
+}, {
+	moduleSpecifier: "@internal/postgres/migration",
+	symbol: "MigrationCLI"
+}];
+function renderCallsToTypeScript(calls, meta) {
+	const imports = buildImports(calls, meta);
+	const operationsBody = calls.map((c) => renderCall(c)).join(",\n");
+	const hasStart = meta.from !== null;
+	const startField = hasStart ? ["  override readonly startContractJson = startContract;"] : [];
+	return [
+		shebangLineFor(detectScaffoldRuntime()),
+		imports,
+		"",
+		`export default class M extends Migration<${hasStart ? "Start" : "never"}, End> {`,
+		...startField,
+		"  override readonly endContractJson = endContract;",
+		"",
+		"  override get operations() {",
+		"    return [",
+		indent(operationsBody, 6),
+		"    ];",
+		"  }",
+		"}",
+		"",
+		"MigrationCLI.run(import.meta.url, M);",
+		""
+	].join("\n");
+}
+function renderCall(call) {
+	return call.renderTypeScript();
+}
+function buildImports(calls, meta) {
+	const requirements = [...BASE_IMPORTS, ...contractImports(meta)];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(resolveRequirementSpecifiers(requirements, meta.resolveImportSpecifier));
+}
+/**
+* The committed contract-JSON imports the scaffold reads its from/to identity
+* from, resolved to the deduplicated snapshot store under
+* `meta.snapshotsImportPath`. The end snapshot is always present; the start
+* snapshot is added only for a non-baseline migration (`meta.from !== null`).
+* The matching `Contract` type imports (aliased `Start`/`End`) feed the
+* `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with
+* no start imports — `never` is the honest "no prior contract" Start.
+*/
+function contractImports(meta) {
+	const reqs = [{
+		moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.to),
+		symbol: "endContract",
+		kind: "default",
+		attributes: { type: "json" }
+	}, {
+		moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.to),
+		symbol: "Contract",
+		alias: "End",
+		typeOnly: true
+	}];
+	if (meta.from !== null) {
+		reqs.push({
+			moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.from),
+			symbol: "startContract",
+			kind: "default",
+			attributes: { type: "json" }
+		});
+		reqs.push({
+			moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.from),
+			symbol: "Contract",
+			alias: "Start",
+			typeOnly: true
+		});
+	}
+	return reqs;
+}
+function indent(text, spaces) {
+	const pad = " ".repeat(spaces);
+	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
+}
+//#endregion
+export { renderCallsToTypeScript as t };
+
+//# sourceMappingURL=render-typescript-Cw3lFO28-Cx0lXWmv.mjs.map

package/dist/render-typescript-Cw3lFO28-Cx0lXWmv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-typescript-Cw3lFO28-Cx0lXWmv.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/render-typescript-Cw3lFO28.mjs"],"sourcesContent":["import { contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier } from \"@internal/framework-components/control\";\nimport { renderImports } from \"@internal/ts-render\";\nimport { resolveRequirementSpecifiers } from \"@internal/framework-components/emission\";\nimport { detectScaffoldRuntime, shebangLineFor } from \"@internal/migration-tools/migration-ts\";\n//#region src/core/migrations/render-typescript.ts\n/**\n* Polymorphic TypeScript emitter for the Postgres migration IR.\n*\n* Each `OpFactoryCall` renders itself via `renderTypeScript()` and\n* declares its own `importRequirements()`; this file just composes the module\n* source around those contributions. The design mirrors the Mongo target's\n* `render-typescript.ts` deliberately — byte-for-byte alignment isn't required\n* (different factory module specifiers, different base-class name) but the\n* shape is, so future consolidation to a framework-level helper is mechanical.\n*/\n/**\n* Always-present base imports for the rendered scaffold. Both come from\n* `@internal/postgres/migration` so an authored Postgres\n* `migration.ts` only needs a single dependency for its base class and\n* its CLI entrypoint:\n*\n* - `Migration` — the facade re-export fixes the `SqlMigration`\n*   generic to `PostgresPlanTargetDetails` and the abstract `targetId`\n*   to `'postgres'`, so user-authored migrations don't need to thread\n*   target-details or redeclare `targetId`.\n* - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n*   `@internal/cli/migration-cli`. Loads `prisma-next.config.ts`,\n*   assembles a `ControlStack`, and instantiates the migration class.\n*   The migration file owns this dependency directly: pulling CLI\n*   machinery in at script run time is acceptable because the script's\n*   whole purpose is to be invoked from the project that owns the\n*   config.\n*/\nconst BASE_IMPORTS = [{\n\tmoduleSpecifier: \"@internal/postgres/migration\",\n\tsymbol: \"Migration\"\n}, {\n\tmoduleSpecifier: \"@internal/postgres/migration\",\n\tsymbol: \"MigrationCLI\"\n}];\nfunction renderCallsToTypeScript(calls, meta) {\n\tconst imports = buildImports(calls, meta);\n\tconst operationsBody = calls.map((c) => renderCall(c)).join(\",\\n\");\n\tconst hasStart = meta.from !== null;\n\tconst startField = hasStart ? [\"  override readonly startContractJson = startContract;\"] : [];\n\treturn [\n\t\tshebangLineFor(detectScaffoldRuntime()),\n\t\timports,\n\t\t\"\",\n\t\t`export default class M extends Migration<${hasStart ? \"Start\" : \"never\"}, End> {`,\n\t\t...startField,\n\t\t\"  override readonly endContractJson = endContract;\",\n\t\t\"\",\n\t\t\"  override get operations() {\",\n\t\t\"    return [\",\n\t\tindent(operationsBody, 6),\n\t\t\"    ];\",\n\t\t\"  }\",\n\t\t\"}\",\n\t\t\"\",\n\t\t\"MigrationCLI.run(import.meta.url, M);\",\n\t\t\"\"\n\t].join(\"\\n\");\n}\nfunction renderCall(call) {\n\treturn call.renderTypeScript();\n}\nfunction buildImports(calls, meta) {\n\tconst requirements = [...BASE_IMPORTS, ...contractImports(meta)];\n\tfor (const call of calls) for (const req of call.importRequirements()) requirements.push(req);\n\treturn renderImports(resolveRequirementSpecifiers(requirements, meta.resolveImportSpecifier));\n}\n/**\n* The committed contract-JSON imports the scaffold reads its from/to identity\n* from, resolved to the deduplicated snapshot store under\n* `meta.snapshotsImportPath`. The end snapshot is always present; the start\n* snapshot is added only for a non-baseline migration (`meta.from !== null`).\n* The matching `Contract` type imports (aliased `Start`/`End`) feed the\n* `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with\n* no start imports — `never` is the honest \"no prior contract\" Start.\n*/\nfunction contractImports(meta) {\n\tconst reqs = [{\n\t\tmoduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.to),\n\t\tsymbol: \"endContract\",\n\t\tkind: \"default\",\n\t\tattributes: { type: \"json\" }\n\t}, {\n\t\tmoduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.to),\n\t\tsymbol: \"Contract\",\n\t\talias: \"End\",\n\t\ttypeOnly: true\n\t}];\n\tif (meta.from !== null) {\n\t\treqs.push({\n\t\t\tmoduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.from),\n\t\t\tsymbol: \"startContract\",\n\t\t\tkind: \"default\",\n\t\t\tattributes: { type: \"json\" }\n\t\t});\n\t\treqs.push({\n\t\t\tmoduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.from),\n\t\t\tsymbol: \"Contract\",\n\t\t\talias: \"Start\",\n\t\t\ttypeOnly: true\n\t\t});\n\t}\n\treturn reqs;\n}\nfunction indent(text, spaces) {\n\tconst pad = \" \".repeat(spaces);\n\treturn text.split(\"\\n\").map((line) => line.trim() ? `${pad}${line}` : line).join(\"\\n\");\n}\n//#endregion\nexport { renderCallsToTypeScript as t };\n\n//# sourceMappingURL=render-typescript-Cw3lFO28.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAM,eAAe,CAAC;CACrB,iBAAiB;CACjB,QAAQ;AACT,GAAG;CACF,iBAAiB;CACjB,QAAQ;AACT,CAAC;AACD,SAAS,wBAAwB,OAAO,MAAM;CAC7C,MAAM,UAAU,aAAa,OAAO,IAAI;CACxC,MAAM,iBAAiB,MAAM,KAAK,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;CACjE,MAAM,WAAW,KAAK,SAAS;CAC/B,MAAM,aAAa,WAAW,CAAC,wDAAwD,IAAI,CAAC;CAC5F,OAAO;EACN,eAAe,sBAAsB,CAAC;EACtC;EACA;EACA,4CAA4C,WAAW,UAAU,QAAQ;EACzE,GAAG;EACH;EACA;EACA;EACA;EACA,OAAO,gBAAgB,CAAC;EACxB;EACA;EACA;EACA;EACA;EACA;CACD,CAAC,CAAC,KAAK,IAAI;AACZ;AACA,SAAS,WAAW,MAAM;CACzB,OAAO,KAAK,iBAAiB;AAC9B;AACA,SAAS,aAAa,OAAO,MAAM;CAClC,MAAM,eAAe,CAAC,GAAG,cAAc,GAAG,gBAAgB,IAAI,CAAC;CAC/D,KAAK,MAAM,QAAQ,OAAO,KAAK,MAAM,OAAO,KAAK,mBAAmB,GAAG,aAAa,KAAK,GAAG;CAC5F,OAAO,cAAc,6BAA6B,cAAc,KAAK,sBAAsB,CAAC;AAC7F;;;;;;;;;;AAUA,SAAS,gBAAgB,MAAM;CAC9B,MAAM,OAAO,CAAC;EACb,iBAAiB,8BAA8B,KAAK,qBAAqB,KAAK,EAAE;EAChF,QAAQ;EACR,MAAM;EACN,YAAY,EAAE,MAAM,OAAO;CAC5B,GAAG;EACF,iBAAiB,+BAA+B,KAAK,qBAAqB,KAAK,EAAE;EACjF,QAAQ;EACR,OAAO;EACP,UAAU;CACX,CAAC;CACD,IAAI,KAAK,SAAS,MAAM;EACvB,KAAK,KAAK;GACT,iBAAiB,8BAA8B,KAAK,qBAAqB,KAAK,IAAI;GAClF,QAAQ;GACR,MAAM;GACN,YAAY,EAAE,MAAM,OAAO;EAC5B,CAAC;EACD,KAAK,KAAK;GACT,iBAAiB,+BAA+B,KAAK,qBAAqB,KAAK,IAAI;GACnF,QAAQ;GACR,OAAO;GACP,UAAU;EACX,CAAC;CACF;CACA,OAAO;AACR;AACA,SAAS,OAAO,MAAM,QAAQ;CAC7B,MAAM,MAAM,IAAI,OAAO,MAAM;CAC7B,OAAO,KAAK,MAAM,IAAI,CAAC,CAAC,KAAK,SAAS,KAAK,KAAK,IAAI,GAAG,MAAM,SAAS,IAAI,CAAC,CAAC,KAAK,IAAI;AACtF"}

package/dist/resolve-ddl-schema-CxqlLW47-0GiHRziS.mjs

@@ -0,0 +1,22 @@
+import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
+import { d as isPostgresSchema } from "./postgres-schema-KSzLDONj-CsXGoY8b.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+//#region ../../../3-targets/3-targets/postgres/dist/resolve-ddl-schema-CxqlLW47.mjs
+/**
+* Given the contract's storage and a namespace id, returns the live Postgres
+* DDL schema name that namespace maps to. A named Postgres namespace dispatches
+* to its `ddlSchemaName(storage)`; the unbound sentinel resolves to
+* `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a
+* bare object payload (used by some tests) falls back to the namespace id
+* itself.
+*/
+function resolveDdlSchemaForNamespaceStorage(storage, namespaceId) {
+	if (namespaceId === UNBOUND_NAMESPACE_ID) return DEFAULT_NAMESPACE_ID;
+	const namespace = storage.namespaces[namespaceId];
+	if (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
+	return namespaceId;
+}
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage as t };
+
+//# sourceMappingURL=resolve-ddl-schema-CxqlLW47-0GiHRziS.mjs.map

package/dist/resolve-ddl-schema-CxqlLW47-0GiHRziS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-ddl-schema-CxqlLW47-0GiHRziS.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/resolve-ddl-schema-CxqlLW47.mjs"],"sourcesContent":["import { t as DEFAULT_NAMESPACE_ID } from \"./namespace-ids-xtp_ZY86.mjs\";\nimport { r as isPostgresSchema } from \"./postgres-schema-KSzLDONj.mjs\";\nimport { UNBOUND_NAMESPACE_ID } from \"@internal/framework-components/ir\";\n//#region src/core/migrations/resolve-ddl-schema.ts\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*/\nfunction resolveDdlSchemaForNamespaceStorage(storage, namespaceId) {\n\tif (namespaceId === UNBOUND_NAMESPACE_ID) return DEFAULT_NAMESPACE_ID;\n\tconst namespace = storage.namespaces[namespaceId];\n\tif (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);\n\treturn namespaceId;\n}\n//#endregion\nexport { resolveDdlSchemaForNamespaceStorage as t };\n\n//# sourceMappingURL=resolve-ddl-schema-CxqlLW47.mjs.map"],"mappings":";;;;;;;;;;;;AAYA,SAAS,oCAAoC,SAAS,aAAa;CAClE,IAAI,gBAAgB,sBAAsB,OAAO;CACjD,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GAAG,OAAO,UAAU,cAAc,OAAO;CACpF,OAAO;AACR"}

package/dist/runtime-BbSRVwdd.d.mts

@@ -0,0 +1,12 @@
+import { t as PostgresContract } from "./postgres-schema-Xsjt3RKO-Buv2X8ai.mjs";
+import { l as PostgresLoweredStatement } from "./types-CkryN1AS-6MNZLjLY.mjs";
+import { Adapter, AnyQueryAst } from "@prisma/orm-family-sql/relational-core/ast";
+import { SqlRuntimeAdapterDescriptor } from "@prisma/orm-family-sql/runtime";
+import { RuntimeAdapterInstance } from "@prisma/orm-framework/components/execution";
+//#region ../../../3-targets/6-adapters/postgres/dist/runtime.d.mts
+//#region src/exports/runtime.d.ts
+interface SqlRuntimeAdapter extends RuntimeAdapterInstance<'sql', 'postgres'>, Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}
+declare const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>;
+//#endregion
+export { postgresRuntimeAdapterDescriptor as n, SqlRuntimeAdapter as t };
+//# sourceMappingURL=runtime-BbSRVwdd.d.mts.map

package/dist/runtime-BbSRVwdd.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-BbSRVwdd.d.mts","names":[],"sources":["../../../../3-targets/6-adapters/postgres/dist/runtime.d.mts"],"mappings":";;;;;;;UAKU,0BAA0B,2CAA2C,QAAQ,aAAa,kBAAkB;cACxG,kCAAkC,wCAAwC"}

package/dist/runtime-CDewySU9.d.mts

@@ -0,0 +1,55 @@
+import { SqlDriver } from "@prisma/orm-family-sql/relational-core/ast";
+import { Client, Pool, QueryResult, QueryResultRow } from "pg";
+import { RuntimeDriverDescriptor, RuntimeDriverInstance } from "@prisma/orm-framework/components/execution";
+//#region ../../../3-targets/7-drivers/postgres/dist/runtime.d.mts
+//#region src/postgres-driver.d.ts
+type QueryResult$1<T extends QueryResultRow = QueryResultRow> = QueryResult<T>;
+/**
+ * Concurrency contract: the driver serializes queries per physical client, so
+ * overlapping calls on a `pgClient` binding, a pinned connection, or a
+ * transaction handle run strictly sequentially in FIFO order. Pool bindings
+ * run each driver-level call on its own pool client and are unaffected.
+ *
+ * Lock lifetime: buffered execution (cursors disabled) locks the client only
+ * while fetching; row iteration is lock-free, so a nested query on the same
+ * client inside `for await` works. Cursor-enabled streams hold the lock for
+ * the stream's entire lifetime — a nested query on the same client inside
+ * stream iteration deadlocks, exactly as under pg@8's queue.
+ */
+type PostgresBinding = {
+  readonly kind: 'url';
+  readonly url: string;
+} | {
+  readonly kind: 'pgPool';
+  readonly pool: Pool;
+} | {
+  readonly kind: 'pgClient';
+  readonly client: Client;
+};
+interface PostgresCursorOptions {
+  readonly batchSize?: number;
+  readonly disabled?: boolean;
+}
+interface PostgresDriverOptions {
+  readonly connect: {
+    client: Client;
+  } | {
+    pool: Pool;
+  };
+  readonly cursor?: PostgresCursorOptions | undefined;
+  /**
+   * Use server-side prepared statements for `executePrepared`. Default
+   * `true`. Set `false` when running behind a transaction-mode pooler that
+   * does not support session-scoped prepared statements (e.g. PgBouncer
+   * transaction mode).
+   */
+  readonly preparedStatements?: boolean | undefined;
+}
+type PostgresDriverCreateOptions = Omit<PostgresDriverOptions, 'connect'>;
+//#endregion
+//#region src/exports/runtime.d.ts
+type PostgresRuntimeDriver = RuntimeDriverInstance<'sql', 'postgres'> & SqlDriver<PostgresBinding>;
+declare const postgresRuntimeDriverDescriptor: RuntimeDriverDescriptor<'sql', 'postgres', PostgresDriverCreateOptions, PostgresRuntimeDriver>;
+//#endregion
+export { postgresRuntimeDriverDescriptor as a, QueryResult$1 as i, PostgresDriverCreateOptions as n, PostgresRuntimeDriver as r, PostgresBinding as t };
+//# sourceMappingURL=runtime-CDewySU9.d.mts.map

package/dist/runtime-CDewySU9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-CDewySU9.d.mts","names":[],"sources":["../../../../3-targets/7-drivers/postgres/dist/runtime.d.mts"],"mappings":";;;;;KAIK,cAAY,UAAU,iBAAiB,kBAAkB,YAAc;;;;;;;;;;;;;KAavE;WACM;WACA;;WAEA;WACA,MAAM;;WAEN;WACA,QAAQ;;UAET;WACC;WACA;;UAED;WACC;IACP,QAAQ;;IAER,MAAM;;WAEC,SAAS;;;;;;;WAOT;;KAEN,8BAA8B,KAAK;;;KAGnC,wBAAwB,2CAA2C,UAAU;cACpE,iCAAiC,2CAA2C,6BAA6B"}

package/dist/runtime-_TfO66h5.d.mts

@@ -0,0 +1,32 @@
+import "./postgres-contract-view-2OP5JnXl-D2fpy4-8.mjs";
+import { AnyCodecDescriptor } from "@prisma/orm-framework/components/codec";
+import { AnyEntityKindDescriptor, Namespace } from "@prisma/orm-framework/components/ir";
+import { SqlNamespaceInput, SqlStorage } from "@prisma/orm-family-sql/contract/types";
+import { SqlContractSerializerBase } from "@prisma/orm-family-sql/family/ir";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma/orm-framework/components/execution";
+import { PreserveEmptyPredicate } from "@prisma/orm-framework/contract/hashing";
+import { JsonObject } from "@prisma/orm-framework/utils/json";
+//#region ../../../3-targets/3-targets/postgres/dist/runtime.d.mts
+//#region src/core/postgres-contract-serializer.d.ts
+declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
+  shouldPreserveEmpty: PreserveEmptyPredicate;
+  constructor(extraPackEntityKinds?: readonly AnyEntityKindDescriptor[]);
+  protected hydrateSqlNamespaceEntry(nsId: string, raw: Record<string, unknown>): Namespace | SqlNamespaceInput;
+  serializeContract(contract: Contract<SqlStorage>): JsonObject;
+}
+//#endregion
+//#region src/exports/runtime.d.ts
+interface PostgresRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'postgres'> {}
+/**
+ * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor` from `@internal/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
+ * `@internal/sql-runtime` consumers narrow to at composition time.
+ *
+ * The target itself contributes no codecs — postgres-specific codecs ship from the postgres adapter and from extension packs (pgvector, arktype-json, etc.).
+ */
+declare const postgresRuntimeTargetDescriptor: RuntimeTargetDescriptor<'sql', 'postgres', PostgresRuntimeTargetInstance> & {
+  readonly codecs: () => readonly AnyCodecDescriptor[];
+};
+//#endregion
+export { PostgresRuntimeTargetInstance as n, postgresRuntimeTargetDescriptor as r, PostgresContractSerializer as t };
+//# sourceMappingURL=runtime-_TfO66h5.d.mts.map

package/dist/runtime-_TfO66h5.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-_TfO66h5.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/runtime.d.mts"],"mappings":";;;;;;;;;;;cAUc,mCAAmC,0BAA0B,SAAS;EAClF,qBAAqB;EACrB,YAAY,gCAAgC;YAClC,yBAAyB,cAAc,KAAK,0BAA0B,YAAY;EAC5F,kBAAkB,UAAU,SAAS,cAAc;;;;UAI3C,sCAAsC;;;;;;;cAOlC,iCAAiC,2CAA2C;WAC/E,uBAAuB"}

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

@@ -0,0 +1,15 @@
+import { SqlStorage } from "@prisma/orm-family-sql/contract/types";
+//#region ../../../3-targets/3-targets/postgres/dist/schema-ir-annotations.d.mts
+//#region src/core/migrations/resolve-ddl-schema.d.ts
+/**
+ * Given the contract's storage and a namespace id, returns the live Postgres
+ * DDL schema name that namespace maps to. A named Postgres namespace dispatches
+ * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to
+ * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a
+ * bare object payload (used by some tests) falls back to the namespace id
+ * itself.
+ */
+declare function resolveDdlSchemaForNamespaceStorage(storage: SqlStorage, namespaceId: string): string;
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage as t };
+//# sourceMappingURL=schema-ir-annotations-DuuYh0gl.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-ir-annotations-DuuYh0gl.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/schema-ir-annotations.d.mts"],"mappings":";;;;;;;;;;;iBAUiB,oCAAoC,SAAS,YAAY"}

package/dist/schema-node-kinds-qlnURWJy-Bo30pwTM.d.mts

@@ -0,0 +1,30 @@
+import { DiffableNode } from "@prisma/orm-framework/components/control";
+import { SqlSchemaIRNode } from "@prisma/orm-family-sql/schema-ir/types";
+//#region ../../../3-targets/3-targets/postgres/dist/schema-node-kinds-qlnURWJy.d.mts
+//#region src/core/schema-ir/schema-node-kinds.d.ts
+/**
+ * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements
+ * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`
+ * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)
+ * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node
+ * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).
+ */
+type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;
+/**
+ * The `nodeKind` discriminant for each Postgres schema-diff node. Each node
+ * carries a unique value; the static `is`/`assert` guards compare against these
+ * identifiers rather than spelling the string inline or using `instanceof`. The
+ * field is an enumerable own property carried on every node instance.
+ */
+declare const PostgresSchemaNodeKind: {
+  readonly database: "postgres-database";
+  readonly namespace: "postgres-namespace";
+  readonly table: "postgres-table";
+  readonly policy: "postgres-policy";
+  readonly role: "postgres-role";
+  readonly nativeEnum: "postgres-native-enum";
+};
+type PostgresSchemaNodeKind = (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];
+//#endregion
+export { SqlSchemaDiffNode as n, PostgresSchemaNodeKind as t };
+//# sourceMappingURL=schema-node-kinds-qlnURWJy-Bo30pwTM.d.mts.map

package/dist/schema-node-kinds-qlnURWJy-Bo30pwTM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-node-kinds-qlnURWJy-Bo30pwTM.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/schema-node-kinds-qlnURWJy.d.mts"],"mappings":";;;;;;;;;;;KAUK,oBAAoB,kBAAkB;;;;;;;cAO7B;WACH;WACA;WACA;WACA;WACA;WACA;;KAEN,iCAAiC,qCAAqC"}

package/dist/sql-utils-BnBlQxyh-DaX9Nb7Z.mjs

@@ -0,0 +1,90 @@
+import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.mjs";
+//#region ../../../3-targets/3-targets/postgres/dist/sql-utils-BnBlQxyh.mjs
+/**
+* Shared SQL utility functions for the Postgres target.
+*
+* These functions handle safe SQL identifier and literal escaping
+* with security validations to prevent injection and encoding issues.
+*
+* They live in `target-postgres` because both the control adapter (used at
+* emit time) and the runtime adapter (used at execute time) need the same
+* escaping/validation behavior, and the target package is the natural shared
+* home that both adapters can depend on without crossing planes.
+*/
+const MAX_IDENTIFIER_LENGTH = 63;
+/**
+* Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
+*
+* Security validations:
+* - Rejects null bytes which could cause truncation or unexpected behavior
+* - Rejects empty identifiers
+* - Warns on identifiers exceeding PostgreSQL's 63-character limit
+*
+* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the identifier contains null bytes or is empty
+*/
+function quoteIdentifier(identifier) {
+	if (identifier.length === 0) throw postgresError("CONTRACT.IDENTIFIER_INVALID", "Identifier cannot be empty", { meta: {
+		value: identifier,
+		context: "identifier"
+	} });
+	if (identifier.includes("\0")) throw postgresError("CONTRACT.IDENTIFIER_INVALID", "Identifier cannot contain null bytes", { meta: {
+		value: identifier.replace(/\0/g, "\\0"),
+		context: "identifier"
+	} });
+	if (identifier.length > MAX_IDENTIFIER_LENGTH) console.warn(`Identifier "${identifier.slice(0, 20)}..." exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character limit and will be truncated`);
+	return `"${identifier.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Escapes a string literal for safe use in SQL statements.
+*
+* Security validations:
+* - Rejects null bytes which could cause truncation or unexpected behavior
+*
+* Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
+* Backslashes are treated as literal characters, not escape sequences.
+*
+* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value contains null bytes
+*/
+function escapeLiteral(value) {
+	if (value.includes("\0")) throw postgresError("CONTRACT.IDENTIFIER_INVALID", "Literal value cannot contain null bytes", { meta: {
+		value: value.replace(/\0/g, "\\0"),
+		context: "literal"
+	} });
+	return value.replace(/'/g, "''");
+}
+/**
+* Builds a qualified name (schema.object) with proper quoting.
+*/
+function qualifyName(schemaName, objectName) {
+	return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;
+}
+/**
+* Quotes a possibly dot-qualified name segment-by-segment:
+* `order_status` -> `"order_status"`, `auth.aal_level` -> `"auth"."aal_level"`.
+* A single-segment name round-trips to exactly {@link quoteIdentifier}; whole-
+* string quoting (`"auth.aal_level"`) would be one wrong identifier.
+*/
+function quoteQualifiedName(name) {
+	return name.split(".").map((segment) => quoteIdentifier(segment)).join(".");
+}
+/**
+* Validates that an enum value doesn't exceed PostgreSQL's label length limit.
+*
+* PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).
+* Unlike identifiers, enum labels that exceed this limit cause an error rather than
+* silent truncation.
+*
+* @param value - The enum value to validate
+* @param enumTypeName - Name of the enum type (for error messages)
+* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value exceeds the maximum length
+*/
+function validateEnumValueLength(value, enumTypeName) {
+	if (new TextEncoder().encode(value).length > MAX_IDENTIFIER_LENGTH) throw postgresError("CONTRACT.IDENTIFIER_INVALID", `Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-byte label limit`, { meta: {
+		value,
+		context: "enum-label"
+	} });
+}
+//#endregion
+export { validateEnumValueLength as a, quoteQualifiedName as i, qualifyName as n, quoteIdentifier as r, escapeLiteral as t };
+
+//# sourceMappingURL=sql-utils-BnBlQxyh-DaX9Nb7Z.mjs.map

package/dist/sql-utils-BnBlQxyh-DaX9Nb7Z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils-BnBlQxyh-DaX9Nb7Z.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/sql-utils-BnBlQxyh.mjs"],"sourcesContent":["import { n as postgresError } from \"./errors-kYxOQjdD.mjs\";\n//#region src/core/sql-utils.ts\n/**\n* Shared SQL utility functions for the Postgres target.\n*\n* These functions handle safe SQL identifier and literal escaping\n* with security validations to prevent injection and encoding issues.\n*\n* They live in `target-postgres` because both the control adapter (used at\n* emit time) and the runtime adapter (used at execute time) need the same\n* escaping/validation behavior, and the target package is the natural shared\n* home that both adapters can depend on without crossing planes.\n*/\nconst MAX_IDENTIFIER_LENGTH = 63;\n/**\n* Validates and quotes a PostgreSQL identifier (table, column, type, schema names).\n*\n* Security validations:\n* - Rejects null bytes which could cause truncation or unexpected behavior\n* - Rejects empty identifiers\n* - Warns on identifiers exceeding PostgreSQL's 63-character limit\n*\n* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the identifier contains null bytes or is empty\n*/\nfunction quoteIdentifier(identifier) {\n\tif (identifier.length === 0) throw postgresError(\"CONTRACT.IDENTIFIER_INVALID\", \"Identifier cannot be empty\", { meta: {\n\t\tvalue: identifier,\n\t\tcontext: \"identifier\"\n\t} });\n\tif (identifier.includes(\"\\0\")) throw postgresError(\"CONTRACT.IDENTIFIER_INVALID\", \"Identifier cannot contain null bytes\", { meta: {\n\t\tvalue: identifier.replace(/\\0/g, \"\\\\0\"),\n\t\tcontext: \"identifier\"\n\t} });\n\tif (identifier.length > MAX_IDENTIFIER_LENGTH) console.warn(`Identifier \"${identifier.slice(0, 20)}...\" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character limit and will be truncated`);\n\treturn `\"${identifier.replace(/\"/g, \"\\\"\\\"\")}\"`;\n}\n/**\n* Escapes a string literal for safe use in SQL statements.\n*\n* Security validations:\n* - Rejects null bytes which could cause truncation or unexpected behavior\n*\n* Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).\n* Backslashes are treated as literal characters, not escape sequences.\n*\n* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value contains null bytes\n*/\nfunction escapeLiteral(value) {\n\tif (value.includes(\"\\0\")) throw postgresError(\"CONTRACT.IDENTIFIER_INVALID\", \"Literal value cannot contain null bytes\", { meta: {\n\t\tvalue: value.replace(/\\0/g, \"\\\\0\"),\n\t\tcontext: \"literal\"\n\t} });\n\treturn value.replace(/'/g, \"''\");\n}\n/**\n* Builds a qualified name (schema.object) with proper quoting.\n*/\nfunction qualifyName(schemaName, objectName) {\n\treturn `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;\n}\n/**\n* Quotes a possibly dot-qualified name segment-by-segment:\n* `order_status` -> `\"order_status\"`, `auth.aal_level` -> `\"auth\".\"aal_level\"`.\n* A single-segment name round-trips to exactly {@link quoteIdentifier}; whole-\n* string quoting (`\"auth.aal_level\"`) would be one wrong identifier.\n*/\nfunction quoteQualifiedName(name) {\n\treturn name.split(\".\").map((segment) => quoteIdentifier(segment)).join(\".\");\n}\n/**\n* Validates that an enum value doesn't exceed PostgreSQL's label length limit.\n*\n* PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).\n* Unlike identifiers, enum labels that exceed this limit cause an error rather than\n* silent truncation.\n*\n* @param value - The enum value to validate\n* @param enumTypeName - Name of the enum type (for error messages)\n* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value exceeds the maximum length\n*/\nfunction validateEnumValueLength(value, enumTypeName) {\n\tif (new TextEncoder().encode(value).length > MAX_IDENTIFIER_LENGTH) throw postgresError(\"CONTRACT.IDENTIFIER_INVALID\", `Enum value \"${value.slice(0, 20)}...\" for type \"${enumTypeName}\" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-byte label limit`, { meta: {\n\t\tvalue,\n\t\tcontext: \"enum-label\"\n\t} });\n}\n//#endregion\nexport { validateEnumValueLength as a, quoteQualifiedName as i, qualifyName as n, quoteIdentifier as r, escapeLiteral as t };\n\n//# sourceMappingURL=sql-utils-BnBlQxyh.mjs.map"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,wBAAwB;;;;;;;;;;;AAW9B,SAAS,gBAAgB,YAAY;CACpC,IAAI,WAAW,WAAW,GAAG,MAAM,cAAc,+BAA+B,8BAA8B,EAAE,MAAM;EACrH,OAAO;EACP,SAAS;CACV,EAAE,CAAC;CACH,IAAI,WAAW,SAAS,IAAI,GAAG,MAAM,cAAc,+BAA+B,wCAAwC,EAAE,MAAM;EACjI,OAAO,WAAW,QAAQ,OAAO,KAAK;EACtC,SAAS;CACV,EAAE,CAAC;CACH,IAAI,WAAW,SAAS,uBAAuB,QAAQ,KAAK,eAAe,WAAW,MAAM,GAAG,EAAE,EAAE,4BAA4B,sBAAsB,uCAAuC;CAC5L,OAAO,IAAI,WAAW,QAAQ,MAAM,MAAM,EAAE;AAC7C;;;;;;;;;;;;AAYA,SAAS,cAAc,OAAO;CAC7B,IAAI,MAAM,SAAS,IAAI,GAAG,MAAM,cAAc,+BAA+B,2CAA2C,EAAE,MAAM;EAC/H,OAAO,MAAM,QAAQ,OAAO,KAAK;EACjC,SAAS;CACV,EAAE,CAAC;CACH,OAAO,MAAM,QAAQ,MAAM,IAAI;AAChC;;;;AAIA,SAAS,YAAY,YAAY,YAAY;CAC5C,OAAO,GAAG,gBAAgB,UAAU,EAAE,GAAG,gBAAgB,UAAU;AACpE;;;;;;;AAOA,SAAS,mBAAmB,MAAM;CACjC,OAAO,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,YAAY,gBAAgB,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG;AAC3E;;;;;;;;;;;;AAYA,SAAS,wBAAwB,OAAO,cAAc;CACrD,IAAI,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,SAAS,uBAAuB,MAAM,cAAc,+BAA+B,eAAe,MAAM,MAAM,GAAG,EAAE,EAAE,iBAAiB,aAAa,yBAAyB,sBAAsB,oBAAoB,EAAE,MAAM;EACjQ;EACA,SAAS;CACV,EAAE,CAAC;AACJ"}

package/dist/sql-utils-DW6fkczF.d.mts

@@ -0,0 +1,62 @@
+//#region ../../../3-targets/3-targets/postgres/dist/sql-utils.d.mts
+//#region src/core/sql-utils.d.ts
+/**
+ * Shared SQL utility functions for the Postgres target.
+ *
+ * These functions handle safe SQL identifier and literal escaping
+ * with security validations to prevent injection and encoding issues.
+ *
+ * They live in `target-postgres` because both the control adapter (used at
+ * emit time) and the runtime adapter (used at execute time) need the same
+ * escaping/validation behavior, and the target package is the natural shared
+ * home that both adapters can depend on without crossing planes.
+ */
+/**
+ * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ * - Rejects empty identifiers
+ * - Warns on identifiers exceeding PostgreSQL's 63-character limit
+ *
+ * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the identifier contains null bytes or is empty
+ */
+declare function quoteIdentifier(identifier: string): string;
+/**
+ * Escapes a string literal for safe use in SQL statements.
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ *
+ * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
+ * Backslashes are treated as literal characters, not escape sequences.
+ *
+ * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value contains null bytes
+ */
+declare function escapeLiteral(value: string): string;
+/**
+ * Builds a qualified name (schema.object) with proper quoting.
+ */
+declare function qualifyName(schemaName: string, objectName: string): string;
+/**
+ * Quotes a possibly dot-qualified name segment-by-segment:
+ * `order_status` -> `"order_status"`, `auth.aal_level` -> `"auth"."aal_level"`.
+ * A single-segment name round-trips to exactly {@link quoteIdentifier}; whole-
+ * string quoting (`"auth.aal_level"`) would be one wrong identifier.
+ */
+declare function quoteQualifiedName(name: string): string;
+/**
+ * Validates that an enum value doesn't exceed PostgreSQL's label length limit.
+ *
+ * PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).
+ * Unlike identifiers, enum labels that exceed this limit cause an error rather than
+ * silent truncation.
+ *
+ * @param value - The enum value to validate
+ * @param enumTypeName - Name of the enum type (for error messages)
+ * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value exceeds the maximum length
+ */
+declare function validateEnumValueLength(value: string, enumTypeName: string): void;
+//#endregion
+export { validateEnumValueLength as a, quoteQualifiedName as i, qualifyName as n, quoteIdentifier as r, escapeLiteral as t };
+//# sourceMappingURL=sql-utils-DW6fkczF.d.mts.map

package/dist/sql-utils-DW6fkczF.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils-DW6fkczF.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/sql-utils.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAsBiB,gBAAgB;;;;;;;;;;;;iBAYhB,cAAc;;;;iBAId,YAAY,oBAAoB;;;;;;;iBAOhC,mBAAmB;;;;;;;;;;;;iBAYnB,wBAAwB,eAAe"}

package/dist/table-source-ikHOZmhD-DriY1Lcr.d.mts

@@ -0,0 +1,15 @@
+import { AnyFromSource, AstRewriter, TableSource } from "@prisma/orm-family-sql/relational-core/ast";
+//#region ../../../3-targets/3-targets/postgres/dist/table-source-ikHOZmhD.d.mts
+//#region src/core/ast/table-source.d.ts
+declare class PostgresTableSource extends TableSource {
+  readonly schema: string | undefined;
+  constructor(options: {
+    readonly name: string;
+    readonly schema?: string;
+    readonly alias?: string;
+  });
+  rewrite(rewriter: AstRewriter): AnyFromSource;
+}
+//#endregion
+export { PostgresTableSource as t };
+//# sourceMappingURL=table-source-ikHOZmhD-DriY1Lcr.d.mts.map

package/dist/table-source-ikHOZmhD-DriY1Lcr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-source-ikHOZmhD-DriY1Lcr.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/table-source-ikHOZmhD.d.mts"],"mappings":";;;cAEc,4BAA4B;WAC/B;EACT,YAAY;aACD;aACA;aACA;;EAEX,QAAQ,UAAU,cAAc"}

package/dist/target.d.mts

@@ -0,0 +1,47 @@
+import { a as PostgresCodecOptions, c as isPostgresCodecDescriptor, i as PostgresCodecDescriptorRegistry, l as postgresCodec, n as AnyPostgresCodecDescriptor, o as buildPostgresCodecDescriptorRegistry, r as PostgresCodecDescriptor, s as definePostgresCodecs, t as AdaptedPostgresCodecDescriptor } from "./codec-descriptor-Bec_zukr-BfvtUqhm.mjs";
+import "./codec-descriptor-Bg-_412t.mjs";
+import { n as PostgresRlsPolicyInput, r as RenderedRlsPolicyLiteral, t as PostgresRlsPolicy } from "./postgres-rls-policy-CnDxf3z9-C3LIHAIG.mjs";
+import { a as PostgresNativeEnumSchemaNode, c as PostgresPolicySchemaNodeInput, d as PostgresTableSchemaNode, f as PostgresTableSchemaNodeInput, i as PostgresNamespaceSchemaNodeInput, l as PostgresRoleSchemaNode, n as PostgresDatabaseSchemaNodeInput, o as PostgresNativeEnumSchemaNodeInput, r as PostgresNamespaceSchemaNode, s as PostgresPolicySchemaNode, t as PostgresDatabaseSchemaNode, u as PostgresRoleSchemaNodeInput } from "./postgres-database-schema-node-CyfpHXDr-BqyozkQE.mjs";
+import { t as PostgresSchemaNodeKind } from "./schema-node-kinds-qlnURWJy-Bo30pwTM.mjs";
+import { t as PostgresColumnDefault } from "./types-ue6jkJyF-BQJzjx1P.mjs";
+import { t as PostgresTableSource } from "./table-source-ikHOZmhD-DriY1Lcr.mjs";
+import { a as PostgresRlsEnablementInput, c as PostgresSchema, d as postgresCreateNamespace, i as PostgresRlsEnablement, l as PostgresUnboundSchema, n as PostgresNativeEnum, o as PostgresRole, r as PostgresNativeEnumInput, s as PostgresRoleInput, t as PostgresContract, u as isPostgresSchema } from "./postgres-schema-Xsjt3RKO-Buv2X8ai.mjs";
+import { n as policyInputFromSerialized, t as SerializedRlsPolicy } from "./types-xa86TkcV.mjs";
+import { i as computeContentHash, n as POLICY_OPERATION_PREDICATES, r as RlsPolicyOperation, t as ContentHashParts } from "./canonicalize-CQlxSR4D-MnrT5gtW.mjs";
+import { _ as PostgresDisableRowLevelSecurity, a as DdlIndexElements, b as PostgresDropType, c as PostgresAlterPolicyRename, d as PostgresCreatePolicy, f as PostgresCreateSchema, g as PostgresDdlVisitor, h as PostgresDdlNode, i as AnyPostgresDdlNode, l as PostgresAlterTable, m as PostgresCreateType, n as AlterTableActionVisitor, o as DropDefaultAction, p as PostgresCreateTable, r as AnyAlterTableAction, s as PostgresAlterIndexRename, t as AddColumnAction, u as PostgresCreateIndex, v as PostgresDropIndex, y as PostgresDropPolicy } from "./nodes-BU-V-aZA-RqwPH68u.mjs";
+import "./ddl-B4Rh8ntj.mjs";
+import { n as postgresResolveDefault, t as parsePostgresDefault } from "./default-normalizer-B36TOul4.mjs";
+import { t as normalizeSchemaNativeType } from "./native-type-normalizer-DqJlOTeX.mjs";
+import { a as validateEnumValueLength, i as quoteQualifiedName, n as qualifyName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-DW6fkczF.mjs";
+import { A as SQL_INT_CODEC_ID, C as PG_TIMETZ_CODEC_ID, D as PG_VARCHAR_CODEC_ID, E as PG_VARBIT_CODEC_ID, M as SQL_TIMESTAMP_CODEC_ID, N as SQL_VARCHAR_CODEC_ID, O as SQL_CHAR_CODEC_ID, S as PG_TIMESTAMP_CODEC_ID, T as PG_UUID_CODEC_ID, _ as PG_JSON_CODEC_ID, a as PG_DATE_CODEC_ID, b as PG_TEXT_CODEC_ID, c as PG_FLOAT8_CODEC_ID, d as PG_INT2_CODEC_ID, f as PG_INT4_CODEC_ID, g as PG_JSONB_CODEC_ID, h as PG_INT_CODEC_ID, i as PG_CHAR_CODEC_ID, j as SQL_TEXT_CODEC_ID, k as SQL_FLOAT_CODEC_ID, l as PG_FLOAT_CODEC_ID, m as PG_INTERVAL_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_ENUM_CODEC_ID, p as PG_INT8_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT4_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INET_CODEC_ID, v as PG_NUMERIC_CODEC_ID, w as PG_TIME_CODEC_ID, x as PG_TIMESTAMPTZ_CODEC_ID, y as PG_TEXT_ARRAY_CODEC_ID } from "./codec-ids-CsOU3xDv-mPI0INiF.mjs";
+import "./codec-ids-fgafMLR7.mjs";
+import { $ as pgUuidColumn, A as isPgEnumParams, B as pgInt2Column, C as PgTimeDescriptor, D as PgUuidDescriptor, E as PgTimetzDescriptor, F as pgEnumDescriptor, G as pgJsonColumn, H as pgInt8Column, I as pgFloat4Column, J as pgTextColumn, K as pgJsonbColumn, L as pgFloat8Column, M as pgBoolColumn, N as pgCharColumn, O as PgVarbitDescriptor, P as pgDateColumn, Q as pgTimetzColumn, R as pgFloatColumn, S as PgTextDescriptor, T as PgTimestamptzDescriptor, U as pgIntColumn, V as pgInt4Column, W as pgIntervalColumn, X as pgTimestampColumn, Y as pgTimeColumn, Z as pgTimestamptzColumn, _ as PgInterval, a as PgDateDescriptor, b as PgJsonbDescriptor, c as PgEnumParams, d as PgFloatDescriptor, et as pgVarbitColumn, f as PgInetDescriptor, g as PgIntDescriptor, h as PgInt8Descriptor, i as PgCharDescriptor, j as pgBitColumn, k as PgVarcharDescriptor, l as PgFloat4Descriptor, m as PgInt4Descriptor, n as PgBoolDescriptor, o as PgEnumCodec, p as PgInt2Descriptor, q as pgNumericColumn, s as PgEnumDescriptor, t as PgBitDescriptor, tt as pgVarcharColumn, u as PgFloat8Descriptor, v as PgIntervalDescriptor, w as PgTimestampDescriptor, x as PgNumericDescriptor, y as PgJsonDescriptor, z as pgInetColumn } from "./codecs-Cvqvb9pV-Cdc51FKY.mjs";
+import { a as JsonValue$1, c as Timestamp, d as VarBit, f as Varchar, i as Interval, l as Timestamptz, n as Char, o as Numeric, r as CodecTypes, s as Time, t as Bit, u as Timetz } from "./codec-types-mWhnDEAf-CAQzGFnF.mjs";
+import "./codec-types-BHwY9Ff-.mjs";
+import { n as postgresCodecRegistry, t as postgresCodecDescriptorRegistry } from "./codecs-DBn-uIv-.mjs";
+import { A as rlsPolicyExistsAst, C as indexExistsAst, D as noNullValuesAst, E as jsonb, F as textArray, I as timestamptz, L as toRegclass, M as tableIsEmptyAst, N as tablePrimaryKeyAst, O as pgTable, P as text, S as extensionExistsAst, T as int8, _ as columnTypeAst, a as IndexExistsCheckBuilder, b as createTable, c as TableExistsCheckBuilder, d as alterTable, f as buildControlTableBootstrapQueries, g as columnNullabilityAst, h as columnExistsAst, i as ExtensionExistsCheckBuilder, j as tableExistsAst, k as rlsEnabledAst, l as TablePrimaryKeyCheckBuilder, m as columnDefaultAst, n as ColumnExistsCheckBuilder, o as RlsEnabledCheckBuilder, p as buildSignMarkerBootstrapQueries, r as ConstraintExistsCheckBuilder, s as RlsPolicyExistsCheckBuilder, t as ColumnDefaultCheckBuilder, u as addColumnAction, v as constraintExistsAst, w as int4, x as dropDefaultAction, y as createSchema } from "./contract-free-DzpGxLfb.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO-_xPQVPF0.mjs";
+import { t as postgresRenderDefault } from "./control-2F195jJk.mjs";
+import { n as DataTransformOptions, r as dataTransform, t as DataTransformClosure } from "./data-transform-Ck5FbyNO-BNE7QlAo.mjs";
+import "./data-transform-BSM7TQpE.mjs";
+import { t as buildPostgresPlanDiff } from "./diff-database-schema-DsoNznGC.mjs";
+import { n as postgresError, t as errorPostgresMigrationStackMissing } from "./errors-DCcVX4j1.mjs";
+import { C as DropIndexCall, D as DropTableCall, E as DropPostgresRlsPolicyCall, F as SetDefaultCall, I as SetNotNullCall, M as RawSqlCall, N as RenameIndexCall, O as EnableRowLevelSecurityCall, P as RenamePostgresRlsPolicyCall, S as DropDefaultCall, T as DropNotNullCall, _ as DataTransformCall, a as AddNotNullColumnWithTempDefaultCall, b as DropColumnCall, c as AlterColumnTypeCall, d as CreateIndexCall, g as CreateTableCall, h as CreateSchemaCall, i as AddNativeEnumValueCall, m as CreatePostgresRlsPolicyCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as CreateNativeEnumTypeCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateExtensionCall, v as DisableRowLevelSecurityCall, w as DropNativeEnumTypeCall, x as DropConstraintCall, y as DropCheckConstraintCall } from "./op-factory-call-jd4cgfjA-CyNT4YVn.mjs";
+import { n as planIssues, t as coalesceSubtreeIssues } from "./issue-planner-jkY6p-Ca.mjs";
+import { t as PostgresContractView } from "./postgres-contract-view-2OP5JnXl-D2fpy4-8.mjs";
+import { t as PostgresMigration } from "./postgres-migration-CDJj7CvD-Bsqs_fVo.mjs";
+import { a as fn, c as placeholder, d as unique, i as createExtension, l as primaryKey, n as checkExpression, o as foreignKey, r as col, s as lit, t as MigrationCLI, u as rawSql } from "./migration-CBSAPE8S.mjs";
+import "./op-factory-call-FEA5mnWH.mjs";
+import "./pack-DFM4tmob.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-B0PQLLUb-qsS6cQqX.mjs";
+import { n as createPostgresMigrationPlanner, t as contractToPostgresDatabaseSchemaNode } from "./planner-DL4Bh5Nk.mjs";
+import { n as buildColumnTypeSql, r as renderDefaultLiteral, t as buildColumnDefaultSql } from "./planner-ddl-builders-ijp60-JO.mjs";
+import { n as resolveIdentityValue, t as buildBuiltinIdentityValue } from "./planner-identity-values-TfEhnoWa.mjs";
+import "./planner-produced-postgres-migration-C3GPZWeC.mjs";
+import { i as hasUniqueConstraint, n as hasForeignKey, r as hasIndex, t as buildSchemaLookupMap } from "./planner-schema-lookup-C4DHAddq.mjs";
+import { n as qualifyTableName, t as buildExpectedFormatType } from "./planner-sql-checks-CFgbRTJw.mjs";
+import { t as renderOps } from "./render-ops-DPwhZt2W.mjs";
+import { t as renderCallsToTypeScript } from "./render-typescript-6sCFvMBh.mjs";
+import { n as PostgresRuntimeTargetInstance, t as PostgresContractSerializer } from "./runtime-_TfO66h5.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./schema-ir-annotations-DuuYh0gl.mjs";
+export { type AdaptedPostgresCodecDescriptor, AddCheckConstraintCall, AddColumnAction, AddColumnCall, AddForeignKeyCall, AddNativeEnumValueCall, AddNotNullColumnWithTempDefaultCall, AddPrimaryKeyCall, AddUniqueCall, AlterColumnTypeCall, type AlterTableActionVisitor, type AnyAlterTableAction, type AnyPostgresCodecDescriptor, type AnyPostgresDdlNode, Bit, Char, CodecTypes, type ColumnDefaultCheckBuilder, type ColumnExistsCheckBuilder, type ConstraintExistsCheckBuilder, type ContentHashParts, CreateExtensionCall, CreateIndexCall, CreateNativeEnumTypeCall, CreatePostgresRlsPolicyCall, CreateSchemaCall, CreateTableCall, DataTransformCall, type DataTransformClosure, type DataTransformOptions, type DdlIndexElements, DisableRowLevelSecurityCall, DropCheckConstraintCall, DropColumnCall, DropConstraintCall, DropDefaultAction, DropDefaultCall, DropIndexCall, DropNativeEnumTypeCall, DropNotNullCall, DropPostgresRlsPolicyCall, DropTableCall, EnableRowLevelSecurityCall, type ExtensionExistsCheckBuilder, type IndexExistsCheckBuilder, Interval, type JsonValue$1 as JsonValue, PostgresMigration as Migration, MigrationCLI, Numeric, PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_BYTEA_CODEC_ID, PG_CHAR_CODEC_ID, PG_DATE_CODEC_ID, PG_ENUM_CODEC_ID, PG_FLOAT4_CODEC_ID, PG_FLOAT8_CODEC_ID, PG_FLOAT_CODEC_ID, PG_INET_CODEC_ID, PG_INT2_CODEC_ID, PG_INT4_CODEC_ID, PG_INT8_CODEC_ID, PG_INTERVAL_CODEC_ID, PG_INT_CODEC_ID, PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID, PG_NUMERIC_CODEC_ID, PG_TEXT_ARRAY_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_UUID_CODEC_ID, PG_VARBIT_CODEC_ID, PG_VARCHAR_CODEC_ID, POLICY_OPERATION_PREDICATES, type PgBitDescriptor, type PgBoolDescriptor, type PgCharDescriptor, type PgDateDescriptor, type PgEnumCodec, type PgEnumDescriptor, type PgEnumParams, type PgFloat4Descriptor, type PgFloat8Descriptor, type PgFloatDescriptor, type PgInetDescriptor, type PgInt2Descriptor, type PgInt4Descriptor, type PgInt8Descriptor, type PgIntDescriptor, type PgInterval, type PgIntervalDescriptor, type PgJsonDescriptor, type PgJsonbDescriptor, type PgNumericDescriptor, type PgTextDescriptor, type PgTimeDescriptor, type PgTimestampDescriptor, type PgTimestamptzDescriptor, type PgTimetzDescriptor, type PgUuidDescriptor, type PgVarbitDescriptor, type PgVarcharDescriptor, PostgresAlterIndexRename, PostgresAlterPolicyRename, PostgresAlterTable, PostgresCodecDescriptor, type PostgresCodecDescriptorRegistry, type PostgresCodecOptions, type PostgresColumnDefault, type PostgresContract, PostgresContractSerializer, PostgresContractView, PostgresCreateIndex, PostgresCreatePolicy, PostgresCreateSchema, PostgresCreateTable, PostgresCreateType, PostgresDatabaseSchemaNode, type PostgresDatabaseSchemaNodeInput, PostgresDdlNode, type PostgresDdlVisitor, PostgresDisableRowLevelSecurity, PostgresDropIndex, PostgresDropPolicy, PostgresDropType, PostgresNamespaceSchemaNode, type PostgresNamespaceSchemaNodeInput, PostgresNativeEnum, type PostgresNativeEnumInput, PostgresNativeEnumSchemaNode, type PostgresNativeEnumSchemaNodeInput, type PostgresPlanTargetDetails, PostgresPolicySchemaNode, type PostgresPolicySchemaNodeInput, PostgresRlsEnablement, type PostgresRlsEnablementInput, PostgresRlsPolicy, type PostgresRlsPolicyInput, PostgresRole, type PostgresRoleInput, PostgresRoleSchemaNode, type PostgresRoleSchemaNodeInput, PostgresRuntimeTargetInstance, PostgresSchema, PostgresSchemaNodeKind, PostgresTableSchemaNode, type PostgresTableSchemaNodeInput, PostgresTableSource, PostgresUnboundSchema, RawSqlCall, RenameIndexCall, RenamePostgresRlsPolicyCall, type RenderedRlsPolicyLiteral, type RlsEnabledCheckBuilder, type RlsPolicyExistsCheckBuilder, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, type SerializedRlsPolicy, SetDefaultCall, SetNotNullCall, type TableExistsCheckBuilder, type TablePrimaryKeyCheckBuilder, Time, Timestamp, Timestamptz, Timetz, TypeScriptRenderablePostgresMigration, VarBit, Varchar, addColumnAction, alterTable, buildBuiltinIdentityValue, buildColumnDefaultSql, buildColumnTypeSql, buildControlTableBootstrapQueries, buildExpectedFormatType, buildPostgresCodecDescriptorRegistry, buildPostgresPlanDiff, buildSchemaLookupMap, buildSignMarkerBootstrapQueries, checkExpression, coalesceSubtreeIssues, col, columnDefaultAst, columnExistsAst, columnNullabilityAst, columnTypeAst, computeContentHash, constraintExistsAst, contractToPostgresDatabaseSchemaNode, createExtension, createPostgresMigrationPlanner, createSchema, createTable, dataTransform, definePostgresCodecs, dropDefaultAction, errorPostgresMigrationStackMissing, escapeLiteral, extensionExistsAst, fn, foreignKey, hasForeignKey, hasIndex, hasUniqueConstraint, indexExistsAst, int4, int8, isPgEnumParams, isPostgresCodecDescriptor, isPostgresSchema, jsonb, lit, noNullValuesAst, normalizeSchemaNativeType, parsePostgresDefault, pgBitColumn, pgBoolColumn, pgCharColumn, pgDateColumn, pgEnumDescriptor, pgFloat4Column, pgFloat8Column, pgFloatColumn, pgInetColumn, pgInt2Column, pgInt4Column, pgInt8Column, pgIntColumn, pgIntervalColumn, pgJsonColumn, pgJsonbColumn, pgNumericColumn, pgTable, pgTextColumn, pgTimeColumn, pgTimestampColumn, pgTimestamptzColumn, pgTimetzColumn, pgUuidColumn, pgVarbitColumn, pgVarcharColumn, placeholder, planIssues, policyInputFromSerialized, postgresCodec, postgresCodecDescriptorRegistry, postgresCodecRegistry, postgresCreateNamespace, postgresError, postgresRenderDefault, postgresResolveDefault, primaryKey, qualifyName, qualifyTableName, quoteIdentifier, quoteQualifiedName, rawSql, renderCallsToTypeScript, renderDefaultLiteral, renderOps, resolveDdlSchemaForNamespaceStorage, resolveIdentityValue, rlsEnabledAst, rlsPolicyExistsAst, tableExistsAst, tableIsEmptyAst, tablePrimaryKeyAst, text, textArray, timestamptz, toRegclass, unique, validateEnumValueLength };