@prisma-next/target-postgres 0.4.0-dev.9 → 0.4.2

package/dist/planner.d.mts

@@ -0,0 +1,68 @@
+import "./shared-Bxkt8pNO.mjs";
+import "./op-factory-call-C3bWXKSP.mjs";
+import "./postgres-migration-BjA3Zmts.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-CRRTno6Z.mjs";
+import { MigrationOperationPolicy, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
+import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+
+//#region src/core/migrations/planner.d.ts
+interface PlannerConfig {
+  readonly defaultSchema: string;
+}
+declare function createPostgresMigrationPlanner(config?: Partial<PlannerConfig>): PostgresMigrationPlanner;
+/**
+ * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose
+ * success variant carries a `TypeScriptRenderablePostgresMigration` — a
+ * migration object that both the CLI (via `renderTypeScript()`) and the
+ * SQL-typed callers (via `operations`, `describe()`, etc.) consume
+ * uniformly.
+ */
+type PostgresPlanResult = {
+  readonly kind: 'success';
+  readonly plan: TypeScriptRenderablePostgresMigration;
+} | SqlPlannerFailureResult;
+/**
+ * Postgres migration planner — a thin wrapper over `planIssues`.
+ *
+ * `plan()` verifies the live schema against the target contract (producing
+ * `SchemaIssue[]`) and delegates to `planIssues` with the unified
+ * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,
+ * type-change, nullable-tightening, codec-hook storage types,
+ * component-declared dependency installs, and shared-temp-default /
+ * empty-table-guarded NOT-NULL add-column. The same strategy list runs for
+ * `migration plan`, `db update`, and `db init`; behavior diverges purely on
+ * `policy.allowedOperationClasses` (the data-safe strategies short-circuit
+ * when `'data'` is excluded). The issue planner applies operation-class
+ * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both
+ * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`
+ * authoring surface.
+ */
+declare class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
+  private readonly config;
+  constructor(config: PlannerConfig);
+  plan(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly fromHash?: string;
+    /**
+     * The "from" contract (state the planner assumes the database starts
+     * at). Only `migration plan` supplies this; `db update` / `db init`
+     * reconcile against the live schema with no old contract. When present
+     * alongside the `'data'` operation class, strategies that need from/to
+     * column shape comparisons (unsafe type change, nullability tightening)
+     * activate.
+     */
+    readonly fromContract?: unknown;
+    readonly schemaName?: string;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  }): PostgresPlanResult;
+  emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface;
+  private planSql;
+  private ensureAdditivePolicy;
+  private collectSchemaIssues;
+}
+//#endregion
+export { createPostgresMigrationPlanner };
+//# sourceMappingURL=planner.d.mts.map

package/dist/planner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAkCU,aAAA;;;iBAQM,8BAAA,UACN,QAAQ,iBACf;;AA3B2F;AAyB9F;;;;;AAgBY,KAAA,kBAAA,GAAkB;EAoBjB,SAAA,IAAA,EAAA,SAAA;EAC0B,SAAA,IAAA,EApBQ,qCAoBR;CAKlB,GAxBjB,uBAwBiB;;;;;;;;;;;;;;;;;cANR,wBAAA,YAAoC;;sBACV;;;;qBAKlB;;;;;;;;;;;;kCAYa,cAAc;MAC1C;0BAIoB,2BAA2B"}

package/dist/planner.mjs

@@ -0,0 +1,4 @@
+import "./issue-planner-CFjB0_oO.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-CLUvVhUN.mjs";
+
+export { createPostgresMigrationPlanner };

package/dist/postgres-migration-BjA3Zmts.d.mts

@@ -0,0 +1,50 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
+import { n as DataTransformOptions, r as PostgresDataTransformOperation } from "./data-transform-CxFRBIUp.mjs";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { Contract } from "@prisma-next/contract/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
+import { ControlStack } from "@prisma-next/framework-components/control";
+
+//#region src/core/migrations/postgres-migration.d.ts
+
+/**
+ * Target-owned base class for Postgres migrations.
+ *
+ * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the
+ * abstract `targetId` to the Postgres target-id string literal, so both
+ * user-authored migrations and renderer-generated scaffolds (the output of
+ * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without
+ * redeclaring target-local identity.
+ *
+ * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer
+ * emits `extends Migration` against a target-specific re-export of this
+ * class from `@prisma-next/target-postgres/migration`, keeping the
+ * authoring surface target-scoped rather than family-scoped.
+ *
+ * The constructor materializes a single Postgres `SqlControlAdapter` from
+ * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`
+ * instance method forwards to the free `dataTransform` factory with that
+ * stored adapter, so user migrations can write `this.dataTransform(...)`
+ * without threading the adapter through every call.
+ */
+declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDetails, 'postgres'> {
+  readonly targetId: "postgres";
+  /**
+   * Materialized Postgres control adapter, created once per migration
+   * instance from the injected stack. `undefined` only when the migration
+   * was instantiated without a stack (test fixtures); `dataTransform`
+   * throws in that case to surface the misuse.
+   */
+  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;
+  constructor(stack?: ControlStack<'sql', 'postgres'>);
+  /**
+   * Instance-method wrapper around the free `dataTransform` factory that
+   * supplies the stored control adapter. Authors call this from inside
+   * `get operations()`; the adapter argument is hidden from the call site.
+   */
+  protected dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): PostgresDataTransformOperation;
+}
+//#endregion
+export { PostgresMigration as t };
+//# sourceMappingURL=postgres-migration-BjA3Zmts.d.mts.map

package/dist/postgres-migration-BjA3Zmts.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-BjA3Zmts.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;AAiCA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,UAC9C;;;;;;;;qCAWmC;sBAEf;;;;;;4CAesB,SAAS,uBACvC,kCAED,uBACR"}

package/dist/postgres-migration-qtmtbONe.mjs

@@ -0,0 +1,52 @@
+import { t as errorPostgresMigrationStackMissing } from "./errors-AFvEPZ1R.mjs";
+import { t as dataTransform } from "./data-transform-VfEGzXWt.mjs";
+import { Migration } from "@prisma-next/family-sql/migration";
+
+//#region src/core/migrations/postgres-migration.ts
+/**
+* Target-owned base class for Postgres migrations.
+*
+* Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the
+* abstract `targetId` to the Postgres target-id string literal, so both
+* user-authored migrations and renderer-generated scaffolds (the output of
+* `renderCallsToTypeScript`) can extend `PostgresMigration` directly without
+* redeclaring target-local identity.
+*
+* Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer
+* emits `extends Migration` against a target-specific re-export of this
+* class from `@prisma-next/target-postgres/migration`, keeping the
+* authoring surface target-scoped rather than family-scoped.
+*
+* The constructor materializes a single Postgres `SqlControlAdapter` from
+* `stack.adapter.create(stack)` and stores it; the protected `dataTransform`
+* instance method forwards to the free `dataTransform` factory with that
+* stored adapter, so user migrations can write `this.dataTransform(...)`
+* without threading the adapter through every call.
+*/
+var PostgresMigration = class extends Migration {
+	targetId = "postgres";
+	/**
+	* Materialized Postgres control adapter, created once per migration
+	* instance from the injected stack. `undefined` only when the migration
+	* was instantiated without a stack (test fixtures); `dataTransform`
+	* throws in that case to surface the misuse.
+	*/
+	controlAdapter;
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter ? stack.adapter.create(stack) : void 0;
+	}
+	/**
+	* Instance-method wrapper around the free `dataTransform` factory that
+	* supplies the stored control adapter. Authors call this from inside
+	* `get operations()`; the adapter argument is hidden from the call site.
+	*/
+	dataTransform(contract, name, options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return dataTransform(contract, name, options, this.controlAdapter);
+	}
+};
+
+//#endregion
+export { PostgresMigration as t };
+//# sourceMappingURL=postgres-migration-qtmtbONe.mjs.map

package/dist/postgres-migration-qtmtbONe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-qtmtbONe.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\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 type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport {\n  type DataTransformOptions,\n  dataTransform,\n  type PostgresDataTransformOperation,\n} from './operations/data-transform';\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 target-specific re-export of this\n * class from `@prisma-next/target-postgres/migration`, keeping the\n * authoring surface 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 */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\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); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\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   * 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  ): PostgresDataTransformOperation {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,AAAS,WAAW;;;;;;;CAQpB,AAAmB;CAEnB,YAAY,OAAyC;AACnD,QAAM,MAAM;AAIZ,OAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,MAAM,GAC5B;;;;;;;CAQN,AAAU,cACR,UACA,MACA,SACgC;AAChC,MAAI,CAAC,KAAK,eACR,OAAM,oCAAoC;AAE5C,SAAO,cAAc,UAAU,MAAM,SAAS,KAAK,eAAe"}

package/dist/render-ops-D6_DHdOK.mjs

@@ -0,0 +1,8 @@
+//#region src/core/migrations/render-ops.ts
+function renderOps(calls) {
+	return calls.map((c) => c.toOp());
+}
+
+//#endregion
+export { renderOps as t };
+//# sourceMappingURL=render-ops-D6_DHdOK.mjs.map

package/dist/render-ops-D6_DHdOK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops-D6_DHdOK.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\nexport function renderOps(calls: readonly PostgresOpFactoryCall[]): Op[] {\n  return calls.map((c) => c.toOp());\n}\n"],"mappings":";AAMA,SAAgB,UAAU,OAA+C;AACvE,QAAO,MAAM,KAAK,MAAM,EAAE,MAAM,CAAC"}

package/dist/render-ops.d.mts

@@ -0,0 +1,11 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
+import "./shared-Bxkt8pNO.mjs";
+import { b as PostgresOpFactoryCall } from "./op-factory-call-C3bWXKSP.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+
+//#region src/core/migrations/render-ops.d.ts
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+declare function renderOps(calls: readonly PostgresOpFactoryCall[]): Op[];
+//#endregion
+export { renderOps };
+//# sourceMappingURL=render-ops.d.mts.map

package/dist/render-ops.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops.d.mts","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":[],"mappings":";;;;;;KAIK,EAAA,GAAK,0BAA0B;iBAEpB,SAAA,iBAA0B,0BAA0B"}

package/dist/render-ops.mjs

@@ -0,0 +1,3 @@
+import { t as renderOps } from "./render-ops-D6_DHdOK.mjs";
+
+export { renderOps };

package/dist/render-typescript-1rF_SB4g.mjs

@@ -0,0 +1,85 @@
+import { jsonToTsSource, renderImports } from "@prisma-next/ts-render";
+import { detectScaffoldRuntime, shebangLineFor } from "@prisma-next/migration-tools/migration-ts";
+
+//#region src/core/migrations/render-typescript.ts
+/**
+* Polymorphic TypeScript emitter for the Postgres migration IR.
+*
+* Each `PostgresOpFactoryCall` 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
+* `@prisma-next/target-postgres/migration` so an authored Postgres
+* `migration.ts` only needs a single dependency for its base class and
+* its CLI entrypoint:
+*
+* - `Migration` — the target-owned 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
+*   `@prisma-next/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: "@prisma-next/target-postgres/migration",
+	symbol: "Migration"
+}, {
+	moduleSpecifier: "@prisma-next/target-postgres/migration",
+	symbol: "MigrationCLI"
+}];
+function renderCallsToTypeScript(calls, meta) {
+	const imports = buildImports(calls);
+	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
+	return [
+		shebangLineFor(detectScaffoldRuntime()),
+		imports,
+		"",
+		"export default class M extends Migration {",
+		buildDescribeMethod(meta),
+		"  override get operations() {",
+		"    return [",
+		indent(operationsBody, 6),
+		"    ];",
+		"  }",
+		"}",
+		"",
+		"MigrationCLI.run(import.meta.url, M);",
+		""
+	].join("\n");
+}
+function buildImports(calls) {
+	const requirements = [...BASE_IMPORTS];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(requirements);
+}
+function buildDescribeMethod(meta) {
+	const lines = [];
+	lines.push("  override describe() {");
+	lines.push("    return {");
+	lines.push(`      from: ${JSON.stringify(meta.from)},`);
+	lines.push(`      to: ${JSON.stringify(meta.to)},`);
+	if (meta.kind) lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
+	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
+	lines.push("    };");
+	lines.push("  }");
+	lines.push("");
+	return lines.join("\n");
+}
+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-1rF_SB4g.mjs.map

package/dist/render-typescript-1rF_SB4g.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-typescript-1rF_SB4g.mjs","names":["BASE_IMPORTS: readonly ImportRequirement[]","requirements: ImportRequirement[]","lines: string[]"],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":["/**\n * Polymorphic TypeScript emitter for the Postgres migration IR.\n *\n * Each `PostgresOpFactoryCall` 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\nimport { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';\nimport { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';\nimport type { PostgresOpFactoryCall } from './op-factory-call';\n\nexport interface RenderMigrationMeta {\n  readonly from: string;\n  readonly to: string;\n  readonly kind?: string;\n  readonly labels?: readonly string[];\n}\n\n/**\n * Always-present base imports for the rendered scaffold. Both come from\n * `@prisma-next/target-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 target-owned 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 *   `@prisma-next/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: readonly ImportRequirement[] = [\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'Migration' },\n  { moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'MigrationCLI' },\n];\n\nexport function renderCallsToTypeScript(\n  calls: ReadonlyArray<PostgresOpFactoryCall>,\n  meta: RenderMigrationMeta,\n): string {\n  const imports = buildImports(calls);\n  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\\n');\n\n  return [\n    shebangLineFor(detectScaffoldRuntime()),\n    imports,\n    '',\n    'export default class M extends Migration {',\n    buildDescribeMethod(meta),\n    '  override get operations() {',\n    '    return [',\n    indent(operationsBody, 6),\n    '    ];',\n    '  }',\n    '}',\n    '',\n    'MigrationCLI.run(import.meta.url, M);',\n    '',\n  ].join('\\n');\n}\n\nfunction buildImports(calls: ReadonlyArray<PostgresOpFactoryCall>): string {\n  const requirements: ImportRequirement[] = [...BASE_IMPORTS];\n  for (const call of calls) {\n    for (const req of call.importRequirements()) {\n      requirements.push(req);\n    }\n  }\n  return renderImports(requirements);\n}\n\nfunction buildDescribeMethod(meta: RenderMigrationMeta): string {\n  const lines: string[] = [];\n  lines.push('  override describe() {');\n  lines.push('    return {');\n  lines.push(`      from: ${JSON.stringify(meta.from)},`);\n  lines.push(`      to: ${JSON.stringify(meta.to)},`);\n  if (meta.kind) {\n    lines.push(`      kind: ${JSON.stringify(meta.kind)},`);\n  }\n  if (meta.labels && meta.labels.length > 0) {\n    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);\n  }\n  lines.push('    };');\n  lines.push('  }');\n  lines.push('');\n  return lines.join('\\n');\n}\n\nfunction indent(text: string, spaces: number): string {\n  const pad = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${pad}${line}` : line))\n    .join('\\n');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAMA,eAA6C,CACjD;CAAE,iBAAiB;CAA0C,QAAQ;CAAa,EAClF;CAAE,iBAAiB;CAA0C,QAAQ;CAAgB,CACtF;AAED,SAAgB,wBACd,OACA,MACQ;CACR,MAAM,UAAU,aAAa,MAAM;CACnC,MAAM,iBAAiB,MAAM,KAAK,MAAM,EAAE,kBAAkB,CAAC,CAAC,KAAK,MAAM;AAEzE,QAAO;EACL,eAAe,uBAAuB,CAAC;EACvC;EACA;EACA;EACA,oBAAoB,KAAK;EACzB;EACA;EACA,OAAO,gBAAgB,EAAE;EACzB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK;;AAGd,SAAS,aAAa,OAAqD;CACzE,MAAMC,eAAoC,CAAC,GAAG,aAAa;AAC3D,MAAK,MAAM,QAAQ,MACjB,MAAK,MAAM,OAAO,KAAK,oBAAoB,CACzC,cAAa,KAAK,IAAI;AAG1B,QAAO,cAAc,aAAa;;AAGpC,SAAS,oBAAoB,MAAmC;CAC9D,MAAMC,QAAkB,EAAE;AAC1B,OAAM,KAAK,0BAA0B;AACrC,OAAM,KAAK,eAAe;AAC1B,OAAM,KAAK,eAAe,KAAK,UAAU,KAAK,KAAK,CAAC,GAAG;AACvD,OAAM,KAAK,aAAa,KAAK,UAAU,KAAK,GAAG,CAAC,GAAG;AACnD,KAAI,KAAK,KACP,OAAM,KAAK,eAAe,KAAK,UAAU,KAAK,KAAK,CAAC,GAAG;AAEzD,KAAI,KAAK,UAAU,KAAK,OAAO,SAAS,EACtC,OAAM,KAAK,iBAAiB,eAAe,KAAK,OAAO,CAAC,GAAG;AAE7D,OAAM,KAAK,SAAS;AACpB,OAAM,KAAK,MAAM;AACjB,OAAM,KAAK,GAAG;AACd,QAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,OAAO,MAAc,QAAwB;CACpD,MAAM,MAAM,IAAI,OAAO,OAAO;AAC9B,QAAO,KACJ,MAAM,KAAK,CACX,KAAK,SAAU,KAAK,MAAM,GAAG,GAAG,MAAM,SAAS,KAAM,CACrD,KAAK,KAAK"}

package/dist/render-typescript.d.mts

@@ -0,0 +1,15 @@
+import "./shared-Bxkt8pNO.mjs";
+import { b as PostgresOpFactoryCall } from "./op-factory-call-C3bWXKSP.mjs";
+
+//#region src/core/migrations/render-typescript.d.ts
+
+interface RenderMigrationMeta {
+  readonly from: string;
+  readonly to: string;
+  readonly kind?: string;
+  readonly labels?: readonly string[];
+}
+declare function renderCallsToTypeScript(calls: ReadonlyArray<PostgresOpFactoryCall>, meta: RenderMigrationMeta): string;
+//#endregion
+export { renderCallsToTypeScript };
+//# sourceMappingURL=render-typescript.d.mts.map

package/dist/render-typescript.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-typescript.d.mts","names":[],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":[],"mappings":";;;;;UAeiB,mBAAA;;;;;;iBA8BD,uBAAA,QACP,cAAc,8BACf"}

package/dist/render-typescript.mjs

@@ -0,0 +1,3 @@
+import { t as renderCallsToTypeScript } from "./render-typescript-1rF_SB4g.mjs";
+
+export { renderCallsToTypeScript };

package/dist/runtime.d.mts

@@ -1,9 +1,21 @@
-import { SqlRuntimeTargetDescriptor } from "@prisma-next/sql-runtime";
-import { RuntimeTargetInstance } from "@prisma-next/framework-components/execution";
+import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma-next/framework-components/execution";
 
 //#region src/exports/runtime.d.ts
 interface PostgresRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'postgres'> {}
-declare const postgresRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<'postgres', PostgresRuntimeTargetInstance>;
+/**
+ * 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`, `parameterizedCodecs`) that
+ * `@prisma-next/sql-runtime` consumers narrow to at composition time.
+ */
+declare const postgresRuntimeTargetDescriptor: RuntimeTargetDescriptor<'sql', 'postgres', PostgresRuntimeTargetInstance> & {
+  readonly codecs: () => ReturnType<typeof createCodecRegistry>;
+  readonly parameterizedCodecs: () => readonly never[];
+};
 //#endregion
 export { PostgresRuntimeTargetInstance, postgresRuntimeTargetDescriptor as default };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;UAKiB,6BAAA,SAAsC;AAAvD,cAEM,+BAFyC,EAER,0BAFqC,CAAA,UAAA,EAI1E,6BAJ0E,CAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;UAOiB,6BAAA,SAAsC;AAAvD;AAAkG;;;;;;;;cAW5F,iCAAiC,2CAGrC;yBAEuB,kBAAkB"}

package/dist/runtime.mjs

@@ -1,7 +1,16 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DkvCmY98.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-BVoVtyp-.mjs";
 import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
 
 //#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`, `parameterizedCodecs`) that
+* `@prisma-next/sql-runtime` consumers narrow to at composition time.
+*/
 const postgresRuntimeTargetDescriptor = {
 	...postgresTargetDescriptorMeta,
 	codecs: () => createCodecRegistry(),

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["postgresRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<\n  'postgres',\n  PostgresRuntimeTargetInstance\n>"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { RuntimeTargetInstance } from '@prisma-next/framework-components/execution';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlRuntimeTargetDescriptor } from '@prisma-next/sql-runtime';\nimport { postgresTargetDescriptorMeta } from '../core/descriptor-meta';\n\nexport interface PostgresRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'postgres'> {}\n\nconst postgresRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<\n  'postgres',\n  PostgresRuntimeTargetInstance\n> = {\n  ...postgresTargetDescriptorMeta,\n  codecs: () => createCodecRegistry(),\n  parameterizedCodecs: () => [],\n  create(): PostgresRuntimeTargetInstance {\n    return {\n      familyId: 'sql',\n      targetId: 'postgres',\n    };\n  },\n};\n\nexport default postgresRuntimeTargetDescriptor;\n"],"mappings":";;;;AAOA,MAAMA,kCAGF;CACF,GAAG;CACH,cAAc,qBAAqB;CACnC,2BAA2B,EAAE;CAC7B,SAAwC;AACtC,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAED,sBAAe"}
+{"version":3,"file":"runtime.mjs","names":["postgresRuntimeTargetDescriptor: RuntimeTargetDescriptor<\n  'sql',\n  'postgres',\n  PostgresRuntimeTargetInstance\n> & {\n  readonly codecs: () => ReturnType<typeof createCodecRegistry>;\n  readonly parameterizedCodecs: () => readonly never[];\n}"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type {\n  RuntimeTargetDescriptor,\n  RuntimeTargetInstance,\n} from '@prisma-next/framework-components/execution';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport { postgresTargetDescriptorMeta } from '../core/descriptor-meta';\n\nexport interface PostgresRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'postgres'> {}\n\n/**\n * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor`\n * from `@prisma-next/sql-runtime`. The target package is a control-plane\n * residence and must not pull the SQL execution-plane package into its\n * dependency closure. The runtime descriptor here is shaped to satisfy the\n * framework's `RuntimeTargetDescriptor` plus the structural\n * `SqlStaticContributions` (`codecs`, `parameterizedCodecs`) that\n * `@prisma-next/sql-runtime` consumers narrow to at composition time.\n */\nconst postgresRuntimeTargetDescriptor: RuntimeTargetDescriptor<\n  'sql',\n  'postgres',\n  PostgresRuntimeTargetInstance\n> & {\n  readonly codecs: () => ReturnType<typeof createCodecRegistry>;\n  readonly parameterizedCodecs: () => readonly never[];\n} = {\n  ...postgresTargetDescriptorMeta,\n  codecs: () => createCodecRegistry(),\n  parameterizedCodecs: () => [],\n  create(): PostgresRuntimeTargetInstance {\n    return {\n      familyId: 'sql',\n      targetId: 'postgres',\n    };\n  },\n};\n\nexport default postgresRuntimeTargetDescriptor;\n"],"mappings":";;;;;;;;;;;;;AAkBA,MAAMA,kCAOF;CACF,GAAG;CACH,cAAc,qBAAqB;CACnC,2BAA2B,EAAE;CAC7B,SAAwC;AACtC,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAED,sBAAe"}

package/dist/shared-Bxkt8pNO.d.mts

@@ -0,0 +1,41 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { ReferentialAction } from "@prisma-next/sql-contract/types";
+
+//#region src/core/migrations/operations/shared.d.ts
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+/**
+ * Literal-args shape for a column definition consumed by `createTable` and
+ * `addColumn`. Fully materialized: codec expansion and default rendering have
+ * already happened in the wrapper.
+ *
+ * - `typeSql` is the column's DDL type string (e.g. `"integer"`, `"SERIAL"`,
+ *   `"varchar(100)"`), already produced by `buildColumnTypeSql` in the
+ *   call-factory wrapper.
+ * - `defaultSql` is the full `DEFAULT …` clause (e.g. `"DEFAULT 42"`) or an
+ *   empty string when the column has no default, matching
+ *   `buildColumnDefaultSql`'s output.
+ */
+interface ColumnSpec {
+  readonly name: string;
+  readonly typeSql: string;
+  readonly defaultSql: string;
+  readonly nullable: boolean;
+}
+/**
+ * Literal-args shape for a foreign key definition. The referenced table is
+ * assumed to live in the same schema as the constrained table.
+ */
+interface ForeignKeySpec {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly references: {
+    readonly table: string;
+    readonly columns: readonly string[];
+  };
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+}
+//#endregion
+export { ForeignKeySpec as n, Op as r, ColumnSpec as t };
+//# sourceMappingURL=shared-Bxkt8pNO.d.mts.map

package/dist/shared-Bxkt8pNO.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-Bxkt8pNO.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"sourcesContent":[],"mappings":";;;;;KAMY,EAAA,GAAK,0BAA0B;;AAA3C;AAcA;AAWA;;;;;;;;;UAXiB,UAAA;;;;;;;;;;UAWA,cAAA;;;;;;;sBAOK;sBACA"}

package/dist/sql-utils-r-Lw535w.mjs

@@ -0,0 +1,76 @@
+//#region src/core/sql-utils.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.
+*/
+var SqlEscapeError = class extends Error {
+	constructor(message, value, kind) {
+		super(message);
+		this.value = value;
+		this.kind = kind;
+		this.name = "SqlEscapeError";
+	}
+};
+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 {SqlEscapeError} If the identifier contains null bytes or is empty
+*/
+function quoteIdentifier(identifier) {
+	if (identifier.length === 0) throw new SqlEscapeError("Identifier cannot be empty", identifier, "identifier");
+	if (identifier.includes("\0")) throw new SqlEscapeError("Identifier cannot contain null bytes", identifier.replace(/\0/g, "\\0"), "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 {SqlEscapeError} If the value contains null bytes
+*/
+function escapeLiteral(value) {
+	if (value.includes("\0")) throw new SqlEscapeError("Literal value cannot contain null bytes", value.replace(/\0/g, "\\0"), "literal");
+	return value.replace(/'/g, "''");
+}
+/**
+* Builds a qualified name (schema.object) with proper quoting.
+*/
+function qualifyName(schemaName, objectName) {
+	return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;
+}
+/**
+* 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 {SqlEscapeError} If the value exceeds the maximum length
+*/
+function validateEnumValueLength(value, enumTypeName) {
+	if (value.length > MAX_IDENTIFIER_LENGTH) throw new SqlEscapeError(`Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character label limit`, value, "literal");
+}
+
+//#endregion
+export { validateEnumValueLength as a, quoteIdentifier as i, escapeLiteral as n, qualifyName as r, SqlEscapeError as t };
+//# sourceMappingURL=sql-utils-r-Lw535w.mjs.map

package/dist/sql-utils-r-Lw535w.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils-r-Lw535w.mjs","names":["value: string","kind: 'identifier' | 'literal'"],"sources":["../src/core/sql-utils.ts"],"sourcesContent":["/**\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 */\n\nexport class SqlEscapeError extends Error {\n  constructor(\n    message: string,\n    public readonly value: string,\n    public readonly kind: 'identifier' | 'literal',\n  ) {\n    super(message);\n    this.name = 'SqlEscapeError';\n  }\n}\n\nconst MAX_IDENTIFIER_LENGTH = 63;\n\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 {SqlEscapeError} If the identifier contains null bytes or is empty\n */\nexport function quoteIdentifier(identifier: string): string {\n  if (identifier.length === 0) {\n    throw new SqlEscapeError('Identifier cannot be empty', identifier, 'identifier');\n  }\n  if (identifier.includes('\\0')) {\n    throw new SqlEscapeError(\n      'Identifier cannot contain null bytes',\n      identifier.replace(/\\0/g, '\\\\0'),\n      'identifier',\n    );\n  }\n  if (identifier.length > MAX_IDENTIFIER_LENGTH) {\n    console.warn(\n      `Identifier \"${identifier.slice(0, 20)}...\" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character limit and will be truncated`,\n    );\n  }\n  return `\"${identifier.replace(/\"/g, '\"\"')}\"`;\n}\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 {SqlEscapeError} If the value contains null bytes\n */\nexport function escapeLiteral(value: string): string {\n  if (value.includes('\\0')) {\n    throw new SqlEscapeError(\n      'Literal value cannot contain null bytes',\n      value.replace(/\\0/g, '\\\\0'),\n      'literal',\n    );\n  }\n  return value.replace(/'/g, \"''\");\n}\n\n/**\n * Builds a qualified name (schema.object) with proper quoting.\n */\nexport function qualifyName(schemaName: string, objectName: string): string {\n  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;\n}\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 {SqlEscapeError} If the value exceeds the maximum length\n */\nexport function validateEnumValueLength(value: string, enumTypeName: string): void {\n  if (value.length > MAX_IDENTIFIER_LENGTH) {\n    throw new SqlEscapeError(\n      `Enum value \"${value.slice(0, 20)}...\" for type \"${enumTypeName}\" exceeds PostgreSQL's ` +\n        `${MAX_IDENTIFIER_LENGTH}-character label limit`,\n      value,\n      'literal',\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,iBAAb,cAAoC,MAAM;CACxC,YACE,SACA,AAAgBA,OAChB,AAAgBC,MAChB;AACA,QAAM,QAAQ;EAHE;EACA;AAGhB,OAAK,OAAO;;;AAIhB,MAAM,wBAAwB;;;;;;;;;;;AAY9B,SAAgB,gBAAgB,YAA4B;AAC1D,KAAI,WAAW,WAAW,EACxB,OAAM,IAAI,eAAe,8BAA8B,YAAY,aAAa;AAElF,KAAI,WAAW,SAAS,KAAK,CAC3B,OAAM,IAAI,eACR,wCACA,WAAW,QAAQ,OAAO,MAAM,EAChC,aACD;AAEH,KAAI,WAAW,SAAS,sBACtB,SAAQ,KACN,eAAe,WAAW,MAAM,GAAG,GAAG,CAAC,4BAA4B,sBAAsB,wCAC1F;AAEH,QAAO,IAAI,WAAW,QAAQ,MAAM,OAAK,CAAC;;;;;;;;;;;;;AAc5C,SAAgB,cAAc,OAAuB;AACnD,KAAI,MAAM,SAAS,KAAK,CACtB,OAAM,IAAI,eACR,2CACA,MAAM,QAAQ,OAAO,MAAM,EAC3B,UACD;AAEH,QAAO,MAAM,QAAQ,MAAM,KAAK;;;;;AAMlC,SAAgB,YAAY,YAAoB,YAA4B;AAC1E,QAAO,GAAG,gBAAgB,WAAW,CAAC,GAAG,gBAAgB,WAAW;;;;;;;;;;;;;AActE,SAAgB,wBAAwB,OAAe,cAA4B;AACjF,KAAI,MAAM,SAAS,sBACjB,OAAM,IAAI,eACR,eAAe,MAAM,MAAM,GAAG,GAAG,CAAC,iBAAiB,aAAa,yBAC3D,sBAAsB,yBAC3B,OACA,UACD"}

package/dist/sql-utils.d.mts

@@ -0,0 +1,59 @@
+//#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.
+ */
+declare class SqlEscapeError extends Error {
+  readonly value: string;
+  readonly kind: 'identifier' | 'literal';
+  constructor(message: string, value: string, kind: 'identifier' | 'literal');
+}
+/**
+ * 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 {SqlEscapeError} 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 {SqlEscapeError} 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;
+/**
+ * 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 {SqlEscapeError} If the value exceeds the maximum length
+ */
+declare function validateEnumValueLength(value: string, enumTypeName: string): void;
+//#endregion
+export { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier, validateEnumValueLength };
+//# sourceMappingURL=sql-utils.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils.d.mts","names":[],"sources":["../src/core/sql-utils.ts"],"sourcesContent":[],"mappings":";;AAYA;AAuBA;AA8BA;AAcA;AAeA;;;;;;cAlFa,cAAA,SAAuB,KAAA;;;;;;;;;;;;;;;iBAuBpB,eAAA;;;;;;;;;;;;iBA8BA,aAAA;;;;iBAcA,WAAA;;;;;;;;;;;;iBAeA,uBAAA"}

package/dist/sql-utils.mjs

@@ -0,0 +1,3 @@
+import { a as validateEnumValueLength, i as quoteIdentifier, n as escapeLiteral, r as qualifyName, t as SqlEscapeError } from "./sql-utils-r-Lw535w.mjs";
+
+export { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier, validateEnumValueLength };