qubu 0.4.0 → 0.4.2

package/dist/introspection.mjs

@@ -1,12 +1,12 @@
-import { a as toSnapshotJsonValue } from "./canonical-BbnqavJm.mjs";
-import { a as hasIntrospectionErrors, i as createIntrospectionDiagnostic, n as introspectedPhysicalIdentityPolicy, r as IntrospectionError, t as mapCatalogToSnapshot } from "./snapshot-DJpfmxhQ.mjs";
-import { n as assertCompleteSchemaSnapshot } from "./complete-D5Djh-zo.mjs";
+import { a as toSnapshotJsonValue } from "./canonical-BXUguqfo.mjs";
+import { a as hasIntrospectionErrors, i as createIntrospectionDiagnostic, n as introspectedPhysicalIdentityPolicy, r as IntrospectionError, t as mapCatalogToSnapshot } from "./snapshot-C-W65HEd.mjs";
+import { n as assertCompleteSchemaSnapshot } from "./complete-WYyVozgK.mjs";
 import "./snapshot.mjs";
 //#region src/introspection/catalog.ts
 /**
-* Materialize every optional object-family collection and deeply freeze the
-* normalized catalog. Catalog text and extension data remain values; this
-* helper never evaluates SQL or assigns persisted logical identities.
+* Materialize every optional object-family collection and deeply freeze the normalized catalog.
+* Catalog text and extension data remain values; this helper never evaluates SQL or assigns
+* persisted logical identities.
 */
 function createCompleteIntrospectionCatalog(catalog) {
 	return deepFreeze({
@@ -64,10 +64,9 @@ function compareColumn(left, right) {
 	return left.ordinalPosition - right.ordinalPosition || compareId$1(left, right);
 }
 /**
-* Freeze nested catalog values without imposing JSON semantics on bigint or
-* opaque driver values. The normalized contract is expected to contain plain
-* records, arrays, and scalar values; unsupported prototypes are retained but
-* still frozen so the operation remains non-destructive.
+* Freeze nested catalog values without imposing JSON semantics on bigint or opaque driver values.
+* The normalized contract is expected to contain plain records, arrays, and scalar values;
+* unsupported prototypes are retained but still frozen so the operation remains non-destructive.
 */
 function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
 	if (value === null || typeof value !== "object") return value;
@@ -80,9 +79,9 @@ function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
 //#endregion
 //#region src/introspection/complete-snapshot.ts
 /**
-* Map a normalized catalog to strict Snapshot v2 data. This is intentionally
-* separate from the Snapshot v1 mapper: complete objects are never fabricated
-* as tables, and catalog references remain evidence rather than logical IDs.
+* Map a normalized catalog to strict Snapshot v2 data. This is intentionally separate from the
+* Snapshot v1 mapper: complete objects are never fabricated as tables, and catalog references
+* remain evidence rather than logical IDs.
 */
 function mapCatalogToCompleteSnapshot(input) {
 	const catalog = createCompleteIntrospectionCatalog(input);
@@ -1288,7 +1287,7 @@ function constraints(table, rows, tableByName, namespace, diagnostics) {
 function mapIndex(rows, table, namespace, diagnostics) {
 	const first = rows[0];
 	const physicalName = text$2(first.index_name);
-	if (!physicalName) return void 0;
+	if (!physicalName) return;
 	const terms = [];
 	for (const row of rows) {
 		const expression = text$2(row.expression);
@@ -1750,7 +1749,7 @@ function reference$2(kind, name, namespace, relation, key, value = name) {
 	};
 }
 function literal(value, dataType) {
-	if (value === void 0) return void 0;
+	if (value === void 0) return;
 	if (value.toUpperCase() === "NULL") return null;
 	if (value.toUpperCase() === "TRUE") return true;
 	if (value.toUpperCase() === "FALSE") return false;
@@ -2825,11 +2824,11 @@ function storage(value) {
 	return { nativeType: text$1(value) ?? "unknown" };
 }
 function factIfPresent(value) {
-	if (value === void 0 || value === null) return void 0;
+	if (value === void 0 || value === null) return;
 	return literalFact(value);
 }
 function literalFact(value) {
-	if (value === void 0) return void 0;
+	if (value === void 0) return;
 	if (value === null) return {
 		kind: "literal",
 		value: null
@@ -2994,7 +2993,7 @@ function constraint(row, table, columnsByNumber, tableByOid, namespace, diagnost
 		...common,
 		expression: sql$1(text$1(row.definition) ?? "CHECK (true)", namespace, table, physicalName)
 	};
-	if (kind !== "f") return void 0;
+	if (kind !== "f") return;
 	const targetTable = tableByOid.get(text$1(row.target_table_oid));
 	if (!targetTable) {
 		diagnostics.push(createIntrospectionDiagnostic({
@@ -3337,7 +3336,7 @@ function stringArray(value) {
 }
 function booleanOption(options, name) {
 	const value = options.find((option) => option.startsWith(`${name}=`));
-	if (value === void 0) return void 0;
+	if (value === void 0) return;
 	const setting = value.slice(name.length + 1).toLowerCase();
 	if (setting === "true" || setting === "on" || setting === "yes") return true;
 	if (setting === "false" || setting === "off" || setting === "no") return false;
@@ -3703,7 +3702,7 @@ function sqliteView(row, sqlText, namespace, diagnostics) {
 	};
 }
 function viewDefinition(sqlText) {
-	if (!sqlText) return void 0;
+	if (!sqlText) return;
 	return sqlText.match(/\bAS\b([\s\S]*)$/i)?.[1]?.trim().replace(/;\s*$/, "") || void 0;
 }
 function attachedDatabaseObject(row, selectedNamespace) {
@@ -3841,7 +3840,7 @@ function triggerCondition(sqlText, _onIndex, beginIndex) {
 	return sqlText.slice(0, beginIndex).match(/\bWHEN\s+([\s\S]+)$/i)?.[1]?.trim();
 }
 function unquoteIdentifier(value) {
-	if (!value) return void 0;
+	if (!value) return;
 	const trimmed = value.trim();
 	if (trimmed.length < 2) return trimmed;
 	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("`") && trimmed.endsWith("`")) return trimmed.slice(1, -1).replace(/(""|``)/g, (match) => match[0]);
@@ -3864,11 +3863,11 @@ function sqliteExtension(data) {
 	};
 }
 function indexExpressionFor(sqlText, position) {
-	if (!sqlText) return void 0;
+	if (!sqlText) return;
 	const open = sqlText.indexOf("(", sqlText.search(/\bON\b/i));
-	if (open < 0) return void 0;
+	if (open < 0) return;
 	const close = matchingParen(sqlText, open);
-	if (close < 0) return void 0;
+	if (close < 0) return;
 	const term = splitSqlList(sqlText.slice(open + 1, close))[position]?.trim();
 	return term && !isSimpleIdentifier(term) ? term : void 0;
 }
@@ -4110,7 +4109,7 @@ function tableConstraints(table, rows, columns, sqlText, namespace) {
 }
 function sqliteIndex(table, row, infoRows, sqlText, namespace, diagnostics, opaqueObjects) {
 	const physicalName = text(row.name);
-	if (!physicalName) return void 0;
+	if (!physicalName) return;
 	const terms = [];
 	const collations = [];
 	for (const info of infoRows.filter((item) => boolean(item.key))) {
@@ -4237,19 +4236,19 @@ function partialPredicate(sqlText, indexName, namespace, table) {
 	return predicate ? sql(predicate, namespace, table, indexName) : void 0;
 }
 function generatedExpressionFor(sqlText, columnName) {
-	if (!sqlText) return void 0;
+	if (!sqlText) return;
 	const open = sqlText.indexOf("(");
-	if (open < 0) return void 0;
+	if (open < 0) return;
 	const close = matchingParen(sqlText, open);
-	if (close < 0) return void 0;
+	if (close < 0) return;
 	const definitions = splitSqlList(sqlText.slice(open + 1, close));
 	for (const definition of definitions) {
 		const identifier = definition.trim().match(/^("(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*)/)?.[1];
 		if (unquoteIdentifier(identifier) !== columnName) continue;
 		const generated = definition.match(/\bAS\s*\(/i);
-		if (!generated || generated.index === void 0) return void 0;
+		if (!generated || generated.index === void 0) return;
 		const generatedOpen = definition.indexOf("(", generated.index);
-		if (generatedOpen < 0) return void 0;
+		if (generatedOpen < 0) return;
 		const generatedClose = matchingParen(definition, generatedOpen);
 		return generatedClose < 0 ? void 0 : definition.slice(generatedOpen + 1, generatedClose).trim();
 	}

package/dist/{json-CUZlv4HT.mjs → json-Db7XRD91.mjs}

@@ -32,8 +32,8 @@ function createDialect(options) {
 	});
 }
 /**
-* Check a capability at runtime for callers that intentionally bypass the
-* typed render boundary or use a dialect supplied by an older integration.
+* Check a capability at runtime for callers that intentionally bypass the typed render boundary or
+* use a dialect supplied by an older integration.
 */
 function assertDialectCapability(dialect, capability) {
 	if (dialect.capabilities?.includes(capability)) return;

package/dist/migration.d.mts

@@ -1,25 +1,25 @@
-import { T as SnapshotJsonValue, m as SnapshotDialect } from "./types-Deo_q43Y.mjs";
-import { S as SnapshotDiffPath, _ as SnapshotDiffObjectKind, b as SnapshotDiffOperationType, f as SnapshotDiffDiagnostic, g as SnapshotDiffObject, m as SnapshotDiffEvidence, u as SnapshotDiff } from "./index-D3ZOwPT-.mjs";
+import { T as SnapshotJsonValue, m as SnapshotDialect } from "./types-BK1COGZe.mjs";
+import { S as SnapshotDiffPath, _ as SnapshotDiffObjectKind, b as SnapshotDiffOperationType, f as SnapshotDiffDiagnostic, g as SnapshotDiffObject, m as SnapshotDiffEvidence, u as SnapshotDiff } from "./index-CPvfEheG.mjs";
 //#region src/migration/types.d.ts
 /** The versioned envelope tag for dialect-neutral migration plans. */
 declare const migrationPlanFormat: "qubu-migration-plan";
 /** The first strict migration-plan format version. */
 declare const migrationPlanVersion: 1;
 /** Safety classifications carried by every planned operation. */
-type MigrationSafety = 'safe' | 'review-required' | 'destructive' | 'unsupported' | 'unknown';
+type MigrationSafety = "safe" | "review-required" | "destructive" | "unsupported" | "unknown";
 /** Lock strength required by a planned operation. */
-type MigrationLockRequirement = 'none' | 'shared' | 'exclusive' | 'unknown';
+type MigrationLockRequirement = "none" | "shared" | "exclusive" | "unknown";
 /** Transaction behavior required by a planned operation. */
-type MigrationTransactionRequirement = 'required' | 'optional' | 'forbidden' | 'unknown';
+type MigrationTransactionRequirement = "required" | "optional" | "forbidden" | "unknown";
 /** Operations that can appear in a migration plan. */
-type MigrationOperationType = 'add' | 'remove' | 'property-change' | 'physical-rename' | 'custom-sql';
+type MigrationOperationType = "add" | "remove" | "property-change" | "physical-rename" | "custom-sql";
 /** A condition a later executor must check before applying an operation. */
-type MigrationPreconditionType = 'snapshot-digest' | 'object-present' | 'object-absent' | 'property-equals';
+type MigrationPreconditionType = "snapshot-digest" | "object-present" | "object-absent" | "property-equals";
 /** An immutable, serializable migration precondition. */
 interface MigrationPrecondition {
   readonly type: MigrationPreconditionType;
   readonly path: SnapshotDiffPath;
-  readonly kind: SnapshotDiffObjectKind | 'custom-sql';
+  readonly kind: SnapshotDiffObjectKind | "custom-sql";
   readonly namespace?: string;
   readonly logicalId?: string;
   readonly physicalName?: string;
@@ -55,7 +55,7 @@ interface MigrationCustomSqlInput {
 }
 /** A user's explicit decision for an unsafe or incomplete fact. */
 interface MigrationDecision {
-  readonly action: 'allow' | 'skip';
+  readonly action: "allow" | "skip";
   readonly reason: string;
   readonly operationId?: string;
   readonly kind?: SnapshotDiffObjectKind;
@@ -64,15 +64,15 @@ interface MigrationDecision {
   readonly code?: MigrationDiagnosticCode;
 }
 /** Why a plan was blocked or needs review. */
-type MigrationDiagnosticCode = 'decision-required' | 'dependency-cycle' | 'invalid-plan' | 'unknown' | 'lossy' | 'unsupported' | 'destructive' | 'ambiguous' | 'custom-sql' | 'dialect-mismatch' | 'non-canonical';
+type MigrationDiagnosticCode = "decision-required" | "dependency-cycle" | "invalid-plan" | "unknown" | "lossy" | "unsupported" | "destructive" | "ambiguous" | "custom-sql" | "dialect-mismatch" | "non-canonical";
 /** A structured plan diagnostic that keeps source diff context. */
 interface MigrationDiagnostic {
   readonly code: MigrationDiagnosticCode;
-  readonly severity: 'error' | 'warning';
+  readonly severity: "error" | "warning";
   readonly message: string;
   readonly path: SnapshotDiffPath;
   readonly operationId?: string;
-  readonly kind?: SnapshotDiffObjectKind | 'custom-sql';
+  readonly kind?: SnapshotDiffObjectKind | "custom-sql";
   readonly namespace?: string;
   readonly logicalId?: string;
   readonly physicalName?: string;
@@ -98,8 +98,8 @@ interface MigrationOperationOrigin {
 interface MigrationOperation {
   readonly id: string;
   readonly type: MigrationOperationType;
-  readonly kind: SnapshotDiffObjectKind | 'custom-sql';
-  readonly objectKind: SnapshotDiffObjectKind | 'custom-sql';
+  readonly kind: SnapshotDiffObjectKind | "custom-sql";
+  readonly objectKind: SnapshotDiffObjectKind | "custom-sql";
   readonly namespace?: string;
   readonly path: SnapshotDiffPath;
   readonly logicalId?: string;
@@ -111,7 +111,7 @@ interface MigrationOperation {
   readonly lock: MigrationLockRequirement;
   readonly transaction: MigrationTransactionRequirement;
   readonly reversible: boolean;
-  readonly reversibility: 'reversible' | 'irreversible';
+  readonly reversibility: "reversible" | "irreversible";
   readonly irreversibleReason?: string;
   readonly preconditions: readonly MigrationPrecondition[];
   readonly dependsOn: readonly string[];
@@ -119,14 +119,14 @@ interface MigrationOperation {
   readonly origin?: MigrationOperationOrigin;
   readonly customSql?: MigrationCustomSql;
   readonly decision?: MigrationDecision;
-  readonly status: 'approved' | 'decision-required' | 'skipped';
+  readonly status: "approved" | "decision-required" | "skipped";
   readonly position: number;
 }
 /** A dependency edge. `from` must appear before `to`. */
 interface MigrationDependency {
   readonly from: string;
   readonly to: string;
-  readonly reason: 'parent-before-child' | 'child-before-parent' | 'reference-before-dependent' | 'explicit-custom-sql';
+  readonly reason: "parent-before-child" | "child-before-parent" | "reference-before-dependent" | "explicit-custom-sql";
 }
 /** Immutable migration plan data. It contains no executor or SQL renderer. */
 interface MigrationPlan {
@@ -184,10 +184,9 @@ declare class MigrationPlanValidationError extends TypeError {
 /**
  * Convert a resolved SnapshotDiff into an immutable migration plan.
  *
- * This function only describes operations. It does not render SQL, open a
- * connection, execute a transaction, or infer SQL from opaque snapshot data.
- * A plan that still needs a safety decision is returned with `ok: false` so it
- * can be reviewed without being mistaken for an executable plan.
+ * This function only describes operations. It does not render SQL, open a connection, execute a
+ * transaction, or infer SQL from opaque snapshot data. A plan that still needs a safety decision is
+ * returned with `ok: false` so it can be reviewed without being mistaken for an executable plan.
  */
 declare function createMigrationPlan(diff: SnapshotDiff, options?: MigrationPlanOptions): MigrationPlanResult;
 /** Alias for callers that treat plan creation as the main migration action. */

package/dist/migration.mjs

@@ -1,4 +1,4 @@
-import { a as toSnapshotJsonValue, n as canonicalJson } from "./canonical-BbnqavJm.mjs";
+import { a as toSnapshotJsonValue, n as canonicalJson } from "./canonical-BXUguqfo.mjs";
 //#region src/migration/types.ts
 /** The versioned envelope tag for dialect-neutral migration plans. */
 const migrationPlanFormat = "qubu-migration-plan";
@@ -82,10 +82,9 @@ const safetyRank = {
 /**
 * Convert a resolved SnapshotDiff into an immutable migration plan.
 *
-* This function only describes operations. It does not render SQL, open a
-* connection, execute a transaction, or infer SQL from opaque snapshot data.
-* A plan that still needs a safety decision is returned with `ok: false` so it
-* can be reviewed without being mistaken for an executable plan.
+* This function only describes operations. It does not render SQL, open a connection, execute a
+* transaction, or infer SQL from opaque snapshot data. A plan that still needs a safety decision is
+* returned with `ok: false` so it can be reviewed without being mistaken for an executable plan.
 */
 function createMigrationPlan(diff, options = {}) {
 	const diagnostics = [];
@@ -513,7 +512,7 @@ function findDecision(context, decisions, diagnostics, options) {
 	if (direct !== void 0) return direct;
 	const relevantCode = diagnostics.find((diagnostic) => pathRelated(diagnostic.path, context.operation.path))?.code;
 	if (relevantCode !== void 0) return decisions.find((decision) => decision.code === mapDiffCode(relevantCode));
-	if (optionAllows(context.operation.safety, options)) return void 0;
+	if (optionAllows(context.operation.safety, options)) return;
 }
 function requireDecisionsForUnmatchedDiagnostics(diagnostics, contexts, decisions, options, planDiagnostics) {
 	for (const source of diagnostics) {

package/dist/{mysql-CKEKGnj4.mjs → mysql-B_cYzzX2.mjs}

@@ -1,9 +1,239 @@
-import { d as isValidSchemaObjectName, r as isColumnReference } from "./column-D-8OqGuV.mjs";
-import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-CXV8u7Pt.mjs";
-import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.mjs";
-import { a as toSnapshotJsonValue } from "./canonical-BbnqavJm.mjs";
-import { n as createSchemaSnapshot, s as tryCreateSchemaSnapshot } from "./serialize-CFtYYAdk.mjs";
+import { P as isValidSchemaObjectName, r as isColumnReference } from "./column-hqKr7-1I.mjs";
+import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BRMLYwDp.mjs";
+import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
+import { a as toSnapshotJsonValue } from "./canonical-BXUguqfo.mjs";
+import { c as createSchemaSnapshot, p as tryCreateSchemaSnapshot } from "./sqlite-Cg0nwYEH.mjs";
+import { postgresDialect } from "./postgres.mjs";
 import { mysqlDialect } from "./mysql.mjs";
+//#region src/snapshot/postgres.ts
+/** PostgreSQL's v1 snapshot extension identity. */
+const postgresSnapshotDialect = Object.freeze({
+	name: "postgresql",
+	version: 1
+});
+var PostgresSnapshotDialectError = class extends TypeError {
+	code = "dialect-mismatch";
+};
+const postgresStorageTypes = Object.freeze({
+	integer: "INTEGER",
+	numeric: "NUMERIC",
+	text: "TEXT",
+	boolean: "BOOLEAN",
+	date: "DATE",
+	timestamp: "TIMESTAMP",
+	uuid: "UUID",
+	json: "JSONB",
+	bigint: "BIGINT",
+	binary: "BYTEA"
+});
+/** PostgreSQL's query dialect plus its schema metadata behavior. */
+const postgresSchemaDialect = createSchemaDialect(postgresDialect(), {
+	version: 1,
+	validate: validatePostgresSchema,
+	encodeStorage(storage, context) {
+		return encodePostgresStorage(storage, context.dialect);
+	},
+	encodeExpression(expression, context) {
+		return encodePostgresExpression(expression, context.mode, context.dialect);
+	},
+	encodeDialectExtension(extension, context) {
+		return encodePostgresExtension(extension, context.dialect);
+	}
+});
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+const postgresSnapshotAdapter = Object.freeze({ dialect: postgresSchemaDialect });
+/** Create a canonical PostgreSQL schema snapshot. */
+function createPostgresSchemaSnapshot(schema, options = {}) {
+	return createSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+/** Return PostgreSQL capability diagnostics without throwing. */
+function tryCreatePostgresSchemaSnapshot(schema, options = {}) {
+	return tryCreateSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+function encodePostgresStorage(storage, dialect) {
+	if (storage.kind === "native") {
+		if (storage.dialect !== dialect.name) throw new TypeError(`PostgreSQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
+		if (storage.type.trim().length === 0) throw new TypeError("PostgreSQL native storage declarations cannot be empty");
+		return {
+			kind: "native",
+			dialect: dialect.name,
+			type: storage.type
+		};
+	}
+	const type = postgresStorageTypes[storage.type];
+	if (type === void 0) throw new TypeError(`Unsupported portable storage type for PostgreSQL: ${String(storage.type)}`);
+	return {
+		kind: "native",
+		dialect: dialect.name,
+		type
+	};
+}
+function encodePostgresExpression(expression, mode, dialect) {
+	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new PostgresSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the PostgreSQL schema dialect is "${dialect.name}"`);
+	const rendered = renderSchemaExpression(expression, {
+		mode,
+		dialect
+	});
+	if (rendered.parameters.length !== 0) throw new TypeError("PostgreSQL schema expressions must be parameter-free");
+	return {
+		kind: "expression",
+		expressionKind: expression.expressionKind,
+		sql: rendered.text,
+		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
+	};
+}
+function encodePostgresExtension(extension, dialect) {
+	if (extension.dialect !== dialect.name) throw new TypeError(`PostgreSQL schema extensions require dialect "${dialect.name}"`);
+	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
+	return {
+		dialect: dialect.name,
+		version: dialect.schema.version,
+		data: sortSnapshotJson$1(toSnapshotJsonValue(data))
+	};
+}
+function sortSnapshotJson$1(value) {
+	if (Array.isArray(value)) return value.map(sortSnapshotJson$1);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson$1(child)]));
+}
+function validatePostgresSchema(schema, context) {
+	const diagnostics = [];
+	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds$1(left, right));
+	const relationNames = /* @__PURE__ */ new Map();
+	if (schema.namespace !== void 0) validatePostgresName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
+	for (const [id, entry] of tableEntries) {
+		const tablePath = ["tables", id];
+		validatePostgresName(entry.physicalName, [...tablePath, "physicalName"], "PostgreSQL table", diagnostics);
+		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
+	}
+	for (const [id, entry] of tableEntries) validatePostgresTable(id, entry, context, relationNames, diagnostics);
+	return Object.freeze(diagnostics);
+}
+function validatePostgresTable(tableId, entry, context, relationNames, diagnostics) {
+	const table = entry.table;
+	const tablePath = ["tables", tableId];
+	const definitions = table.definitions;
+	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds$1(left, right))) {
+		validatePostgresName(table.sqlNames[columnId] ?? columnId, [
+			...tablePath,
+			"columns",
+			columnId,
+			"physicalName"
+		], "PostgreSQL column", diagnostics);
+		if (definition.onUpdate !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL ON UPDATE expressions are not supported by PostgreSQL",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"onUpdate"
+			]
+		});
+		const generated = definition.generatedColumn;
+		if (generated !== void 0 && generated.kind === "expression" && generated.mode === "virtual") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL v1 snapshots support stored generated columns only; virtual generated columns are not supported",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"generatedColumn",
+				"mode"
+			]
+		});
+	}
+	const metadata = table;
+	const constraintNames = /* @__PURE__ */ new Map();
+	const constraints = Object.entries(metadata.constraints);
+	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds$1(left, right))) {
+		const constraintPath = [
+			...tablePath,
+			"constraints",
+			constraintId
+		];
+		const physicalName = constraint.physicalName ?? constraintId;
+		validatePostgresName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
+		addScopedName$1(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
+		appendMetadataDiagnostics$1(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
+		if (constraint.kind === "check" && constraint.deferrable === true) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL CHECK constraints cannot be DEFERRABLE",
+			path: [...constraintPath, "deferrable"]
+		});
+		if (constraint.kind === "foreign-key" && constraint.match === "partial") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL does not implement MATCH PARTIAL foreign keys",
+			path: [...constraintPath, "match"]
+		});
+		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL NULLS NOT DISTINCT requires a server-version policy; the v1 adapter does not assume PostgreSQL 15 or newer",
+			path: [...constraintPath, "nulls"]
+		});
+	}
+	const indexes = Object.entries(metadata.indexes);
+	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds$1(left, right))) {
+		const indexPath = [
+			...tablePath,
+			"indexes",
+			indexId
+		];
+		const physicalName = index.physicalName ?? indexId;
+		validatePostgresName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
+		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
+		appendMetadataDiagnostics$1(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
+	}
+}
+function validatePostgresName(name, path, kind, diagnostics) {
+	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
+		code: "invalid-schema",
+		message: `${kind} name "${name}" is not a valid unqualified identifier`,
+		path
+	});
+	if (new TextEncoder().encode(name).length > 63) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${kind} name exceeds PostgreSQL's 63-byte identifier limit`,
+		path
+	});
+}
+function addRelationName(names, name, path, kind, diagnostics) {
+	addScopedName$1(names, name, path, kind, diagnostics);
+}
+function addScopedName$1(names, name, path, kind, diagnostics) {
+	const previousPath = names.get(name);
+	if (previousPath !== void 0) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: `PostgreSQL ${kind} name "${name}" collides with another relation or metadata object`,
+			path,
+			relatedPaths: [previousPath]
+		});
+		return;
+	}
+	names.set(name, path);
+}
+function appendMetadataDiagnostics$1(diagnostics, issues) {
+	for (const issue of issues) {
+		if (issue.code === "dialect-mismatch") continue;
+		diagnostics.push({
+			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
+			message: issue.message,
+			path: issue.path,
+			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
+		});
+	}
+}
+function compareIds$1(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
 //#region src/snapshot/mysql.ts
 /** MySQL's v1 snapshot extension identity. */
 const mysqlSnapshotDialect = Object.freeze({
@@ -293,7 +523,7 @@ function validateMysqlAutoIncrement(columnId, definition, metadata, columnPath,
 	});
 }
 function mysqlDeclaration(storage) {
-	if (storage === void 0) return void 0;
+	if (storage === void 0) return;
 	return storage.kind === "native" ? storage.type : mysqlStorageTypes[storage.type];
 }
 function isMysqlIntegerDeclaration(declaration) {
@@ -352,4 +582,4 @@ function compareIds(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
 //#endregion
-export { tryCreateMysqlSchemaSnapshot as a, mysqlSnapshotDialect as i, mysqlSchemaDialect as n, mysqlSnapshotAdapter as r, createMysqlSchemaSnapshot as t };
+export { tryCreateMysqlSchemaSnapshot as a, postgresSnapshotAdapter as c, mysqlSnapshotDialect as i, postgresSnapshotDialect as l, mysqlSchemaDialect as n, createPostgresSchemaSnapshot as o, mysqlSnapshotAdapter as r, postgresSchemaDialect as s, createMysqlSchemaSnapshot as t, tryCreatePostgresSchemaSnapshot as u };

package/dist/mysql.d.mts

@@ -1,5 +1,5 @@
-import { V as Dialect } from "./types-Deo_q43Y.mjs";
+import { V as Dialect } from "./types-BK1COGZe.mjs";
 //#region src/dialects/mysql.d.ts
-declare function mysqlDialect(): Dialect<"json" | "row-locking">;
+declare function mysqlDialect(): Dialect<"row-locking" | "json">;
 //#endregion
 export { mysqlDialect };

package/dist/mysql.mjs

@@ -1,4 +1,4 @@
-import { o as createDialect, t as mysqlJson } from "./json-CUZlv4HT.mjs";
+import { o as createDialect, t as mysqlJson } from "./json-Db7XRD91.mjs";
 import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
 import { t as mysqlExplain } from "./explain-CkIK13L_.mjs";
 //#region src/dialects/mysql.ts
@@ -18,11 +18,11 @@ function renderMySqlPagination(context, parts) {
 	const fetch = parts.find((part) => part.kind === "fetch");
 	const offset = parts.find((part) => part.kind === "offset");
 	context.append("LIMIT ");
-	if (fetch) context.parameter(fetch.rows);
+	if (fetch) context.append(String(fetch.rows));
 	else context.append("18446744073709551615");
 	if (offset) {
 		context.append(" OFFSET ");
-		context.parameter(offset.rows);
+		context.append(String(offset.rows));
 	}
 }
 function mysqlDialect() {

package/dist/{on-conflict-4MOBl51J.mjs → on-conflict-hfPW0KmQ.mjs}

@@ -1,9 +1,8 @@
-import { a as assertDialectCapability } from "./json-CUZlv4HT.mjs";
+import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
 import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
-import { C as fragment, g as isExpression, i as identifier, t as createColumnReference } from "./column-D-8OqGuV.mjs";
-import { a as columnResultValue } from "./column-LV7oGQde.mjs";
+import { K as fragment, i as identifier, t as createColumnReference, u as columnResultValue, z as isExpression } from "./column-hqKr7-1I.mjs";
 import { t as omit } from "./omit-OxV58AwX.mjs";
-import { r as exposeColumns, t as createSource } from "./source-DGO3DRgg.mjs";
+import { r as exposeColumns, t as createSource } from "./source-BcS2AsIg.mjs";
 //#region src/query/mutation/on-conflict.ts
 /** Columns from the proposed INSERT row, available inside DO UPDATE. */
 function excluded(table) {

package/dist/postgres.d.mts

@@ -1,12 +1,12 @@
-import { An as excluded, Au as SqlBoolean, Ba as Operand, Ca as ComparisonValidation, Cn as ConflictTarget, Dn as OnConflictClause, Du as AnySqlType, En as ExcludedSource, Gu as SqlUnknown, Ha as OperandSqlType, Hu as SqlTextLike, On as doNothing, Sn as ConflictAction, Tn as DoUpdateAction, Ua as SqlCapabilityValidation, V as Dialect, Va as OperandNullability, Wl as ExpressionMeta, fu as RequiresCapabilityMeta, jn as onConflict, kn as doUpdate, tu as MetadataOf, vl as ExpressionWithOutput, vu as ResultMeta, wn as DoNothingAction, yl as SchemaExpression } from "./types-Deo_q43Y.mjs";
+import { Au as SqlBoolean, Do as SqlCapabilityValidation, Du as AnySqlType, Eo as OperandSqlType, Gu as SqlUnknown, Hu as SqlTextLike, To as OperandNullability, V as Dialect, Wl as ExpressionMeta, _n as doNothing, bn as onConflict, dn as ConflictAction, fn as ConflictTarget, fu as RequiresCapabilityMeta, gn as OnConflictClause, hn as ExcludedSource, mn as DoUpdateAction, pn as DoNothingAction, so as ComparisonValidation, tu as MetadataOf, vl as ExpressionWithOutput, vn as doUpdate, vu as ResultMeta, wo as Operand, yl as SchemaExpression, yn as excluded } from "./types-BK1COGZe.mjs";
 //#region src/dialects/postgres.d.ts
 /**
- * PostgreSQL's only core rendering difference is positional parameters.
- * PostgreSQL-specific expressions and clauses should remain separate modules.
+ * PostgreSQL's only core rendering difference is positional parameters. PostgreSQL-specific
+ * expressions and clauses should remain separate modules.
  */
-declare function postgresDialect(): Dialect<"json" | "ilike" | "on-conflict" | "row-locking">;
+declare function postgresDialect(): Dialect<"row-locking" | "json" | "ilike" | "on-conflict">;
 /** PostgreSQL's case-insensitive pattern-match operator. */
-declare function ilike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, 'ILIKE'>, pattern: R): SchemaExpression<ResultMeta<boolean, ((MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+declare function ilike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, "ILIKE">, pattern: R): SchemaExpression<ResultMeta<boolean, ((MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
   readonly kind: "result";