qubu 0.6.0 → 0.6.2

package/dist/schema.mjs

@@ -1,8 +1,9 @@
-import { c as dialectMismatchDiagnostic, d as isValidSchemaObjectName, f as materializeSchemaObjectIdentity, l as freezeSchemaMetadata, o as SchemaMetadataValidationError, p as materializeSchemaObjectRecord, s as assertSchemaDialectSupport, u as generatedSchemaObjectName } from "./column-r1Y4ivwt.mjs";
-import { C as identityColumn, S as generatedColumn, _ as uuid, a as columnResultValue, b as externalDefault, c as integer, d as nativeStorage, f as nullable, g as timestamp, h as text, i as column, l as json, m as portableStorage, n as binary, o as date, p as numeric, r as boolean, s as encodeColumnParameter, t as bigint, u as nativeColumn, v as ColumnBehaviorError, w as resolveColumnBehavior, x as externalGeneratedColumn, y as canonicalLiteral } from "./column-Da37jYSD.mjs";
-import { i as sourceIdentity, n as customSource, r as exposeColumns, t as createSource } from "./source-SqrKWjFJ.mjs";
-import { n as alias, r as lateral, t as table } from "./table-BwflqeAj.mjs";
-import { a as primaryKey, c as uniqueConstraint, d as validateIndexDialect, i as foreignKey, l as validateConstraintDialect, n as catalogForeignKey, o as references, r as check, s as unique, t as catalogCheck, u as index } from "./constraints-YGyNPQ_z.mjs";
-import { a as schemaNamingPolicyVersion, c as isUnsafeSchemaSql, d as renderSchemaSql, f as schemaExpression, i as schema, l as normalizeSchemaSql, n as defaultSchemaNamingPolicy, o as SchemaExpressionError, p as unsafeSchemaSql, r as generatedTableName, s as defineSchemaExpression, t as SchemaValidationError, u as renderSchemaExpression } from "./registry-BRcUuazJ.mjs";
+import { _ as generatedSchemaObjectName, b as materializeSchemaObjectRecord, c as externalDefault, d as identityColumn, f as resolveColumnBehavior, g as freezeSchemaMetadata, h as dialectMismatchDiagnostic, l as externalGeneratedColumn, m as assertSchemaDialectSupport, o as ColumnBehaviorError, p as SchemaMetadataValidationError, s as canonicalLiteral, u as generatedColumn, v as isValidSchemaObjectName, y as materializeSchemaObjectIdentity } from "./column-DDRvD7SF.mjs";
+import { _ as timestamp, a as columnResultValue, c as encodeColumnParameter, d as nativeColumn, f as nativeStorage, g as text, h as portableStorage, i as column, l as integer, m as numeric, n as binary, o as columnSqlType, p as nullable, r as boolean, s as date, t as bigint, u as json, v as uuid } from "./column-Cyc2CMnG.mjs";
+import { i as sourceIdentity, n as customSource, r as exposeColumns, t as createSource } from "./source-DYSUqzvb.mjs";
+import { n as alias, r as lateral, t as table } from "./table-B8zEq0az.mjs";
+import { a as primaryKey, c as uniqueConstraint, d as validateIndexDialect, i as foreignKey, l as validateConstraintDialect, n as catalogForeignKey, o as references, r as check, s as unique, t as catalogCheck, u as index } from "./constraints-CAmi18Uk.mjs";
+import { a as renderSchemaExpression, c as unsafeSchemaSql, i as normalizeSchemaSql, n as defineSchemaExpression, o as renderSchemaSql, r as isUnsafeSchemaSql, s as schemaExpression, t as SchemaExpressionError } from "./expressions-_6JF_J77.mjs";
+import { a as schemaNamingPolicyVersion, i as schema, n as defaultSchemaNamingPolicy, r as generatedTableName, t as SchemaValidationError } from "./registry-BXE_4M9P.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
-export { ColumnBehaviorError, SchemaExpressionError, SchemaMetadataValidationError, SchemaValidationError, alias, assertSchemaDialectSupport, bigint, binary, boolean, canonicalLiteral, catalogCheck, catalogForeignKey, check, column, columnResultValue, createSchemaDialect, createSource, customSource, date, defaultSchemaNamingPolicy, defineSchemaExpression, dialectMismatchDiagnostic, encodeColumnParameter, exposeColumns, externalDefault, externalGeneratedColumn, foreignKey, freezeSchemaMetadata, generatedColumn, generatedSchemaObjectName, generatedTableName, identityColumn, index, integer, isUnsafeSchemaSql, isValidSchemaObjectName, json, lateral, materializeSchemaObjectIdentity, materializeSchemaObjectRecord, nativeColumn, nativeStorage, normalizeSchemaSql, nullable, numeric, portableStorage, primaryKey, references, renderSchemaExpression, renderSchemaSql, resolveColumnBehavior, schema, schemaExpression, schemaNamingPolicyVersion, sourceIdentity, table, text, timestamp, unique, uniqueConstraint, unsafeSchemaSql, uuid, validateConstraintDialect, validateIndexDialect };
+export { ColumnBehaviorError, SchemaExpressionError, SchemaMetadataValidationError, SchemaValidationError, alias, assertSchemaDialectSupport, bigint, binary, boolean, canonicalLiteral, catalogCheck, catalogForeignKey, check, column, columnResultValue, columnSqlType, createSchemaDialect, createSource, customSource, date, defaultSchemaNamingPolicy, defineSchemaExpression, dialectMismatchDiagnostic, encodeColumnParameter, exposeColumns, externalDefault, externalGeneratedColumn, foreignKey, freezeSchemaMetadata, generatedColumn, generatedSchemaObjectName, generatedTableName, identityColumn, index, integer, isUnsafeSchemaSql, isValidSchemaObjectName, json, lateral, materializeSchemaObjectIdentity, materializeSchemaObjectRecord, nativeColumn, nativeStorage, normalizeSchemaSql, nullable, numeric, portableStorage, primaryKey, references, renderSchemaExpression, renderSchemaSql, resolveColumnBehavior, schema, schemaExpression, schemaNamingPolicyVersion, sourceIdentity, table, text, timestamp, unique, uniqueConstraint, unsafeSchemaSql, uuid, validateConstraintDialect, validateIndexDialect };

package/dist/{serialize-BN07IK0v.mjs → serialize-CyobNEx-.mjs}

@@ -1,8 +1,9 @@
-import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
-import { r as isColumnReference, u as generatedSchemaObjectName } from "./column-r1Y4ivwt.mjs";
-import { c as isUnsafeSchemaSql, n as defaultSchemaNamingPolicy, u as renderSchemaExpression } from "./registry-BRcUuazJ.mjs";
+import { _ as generatedSchemaObjectName, r as isColumnReference, s as canonicalLiteral, w as isSchemaExpression } from "./column-DDRvD7SF.mjs";
+import { o as standardDialect } from "./value-CpaUFtjw.mjs";
+import { a as renderSchemaExpression, r as isUnsafeSchemaSql } from "./expressions-_6JF_J77.mjs";
+import { n as defaultSchemaNamingPolicy } from "./registry-BXE_4M9P.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue, f as schemaSnapshotFormat, i as schemaSnapshotFingerprint, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, u as neutralSnapshotDialect } from "./canonical-DMvR9yBe.mjs";
+import { A as neutralSnapshotDialect, M as schemaSnapshotFormat, a as toSnapshotJsonValue, i as schemaSnapshotFingerprint, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot } from "./canonical-B5_ouh-c.mjs";
 //#region src/snapshot/serialize.ts
 const neutralSchemaDialect = createSchemaDialect(Object.freeze({
 	...standardDialect(),
@@ -12,7 +13,7 @@ const neutralSchemaDialect = createSchemaDialect(Object.freeze({
 var SnapshotSerializationError = class extends SnapshotValidationError {
 	name = "SnapshotSerializationError";
 };
-/** Create a neutral or adapter-owned immutable snapshot from a live schema. */
+/** Create an immutable Snapshot v1 value from a live schema. */
 function createSchemaSnapshot(schema, options = {}) {
 	const result = tryCreateSchemaSnapshot(schema, options);
 	if (!result.ok) throw new SnapshotSerializationError(result.diagnostics);
@@ -69,6 +70,7 @@ function tryCreateSchemaSnapshot(schema, options = {}) {
 		ok: false,
 		diagnostics: Object.freeze(diagnostics)
 	};
+	const namespace = schema.namespace ?? "default";
 	const rawSnapshot = {
 		format: schemaSnapshotFormat,
 		version: 1,
@@ -80,8 +82,23 @@ function tryCreateSchemaSnapshot(schema, options = {}) {
 			name: namingPolicy.name,
 			version: namingPolicy.version ?? 1
 		}),
-		...schema.namespace === void 0 ? {} : { namespace: schema.namespace },
-		tables
+		namespace: namespaceFor(dialect.name, namespace),
+		capabilities: capabilitiesFor(dialect.name),
+		tables,
+		views: [],
+		sequences: [],
+		enums: [],
+		domains: [],
+		collations: [],
+		triggers: [],
+		routines: [],
+		partitions: [],
+		policies: [],
+		extensions: [],
+		deferredObjects: [],
+		opaqueObjects: [],
+		comments: [],
+		ownership: []
 	};
 	try {
 		return {
@@ -103,7 +120,7 @@ function tryCreateSchemaSnapshot(schema, options = {}) {
 		};
 	}
 }
-/** Encode a valid snapshot using fixed property order and canonical JSON. */
+/** Encode a valid Snapshot v1 value using canonical JSON. */
 function encodeSchemaSnapshot(snapshot) {
 	const canonical = assertSchemaSnapshot(snapshot);
 	return encodeCanonicalSnapshot(canonical);
@@ -116,16 +133,27 @@ const encodeSnapshot = encodeSchemaSnapshot;
 const fingerprintSchemaSnapshot = schemaSnapshotFingerprint;
 function serializeTable(id, table, physicalName, tableIds, tablesById, dialect, options, diagnostics) {
 	const definitions = table.definitions;
+	const owner = {
+		kind: "table",
+		id
+	};
 	const tableMetadata = table;
+	const tableDialect = tableMetadata.dialect ? encodeExtension(tableMetadata.dialect, dialect, [
+		"tables",
+		id,
+		"dialect"
+	], options, diagnostics) : void 0;
 	return {
+		kind: "table",
 		id,
 		physicalName,
-		columns: Object.entries(definitions).map(([fieldName, definition]) => serializeColumn(fieldName, definition, table.sqlNames[fieldName] ?? fieldName, dialect, options, diagnostics)).sort(compareId),
-		constraints: Object.entries(tableMetadata.constraints).map(([constraintId, constraint]) => serializeConstraint(constraintId, constraint, table, tableIds, tablesById, dialect, options, diagnostics)).filter((constraint) => constraint !== void 0).sort(compareId),
-		indexes: Object.entries(tableMetadata.indexes).map(([indexId, indexMetadata]) => serializeIndex(indexId, indexMetadata, table, dialect, options, diagnostics)).filter((index) => index !== void 0).sort(compareId)
+		columns: Object.entries(definitions).map(([fieldName, definition], ordinalPosition) => serializeColumn(id, fieldName, definition, table.sqlNames[fieldName] ?? fieldName, ordinalPosition + 1, dialect, options, diagnostics)).sort(compareId),
+		constraints: Object.entries(tableMetadata.constraints).map(([constraintId, constraint]) => serializeConstraint(constraintId, constraint, table, owner, tableIds, tablesById, dialect, options, diagnostics)).filter((constraint) => constraint !== void 0).sort(compareId),
+		indexes: Object.entries(tableMetadata.indexes).map(([indexId, indexMetadata]) => serializeIndex(indexId, indexMetadata, table, owner, dialect, options, diagnostics)).filter((index) => index !== void 0).sort(compareId),
+		...tableDialect === void 0 ? {} : { dialect: tableDialect }
 	};
 }
-function serializeColumn(id, definition, physicalName, dialect, options, diagnostics) {
+function serializeColumn(tableId, id, definition, physicalName, ordinalPosition, dialect, options, diagnostics) {
 	const storage = definition.storage ? encodeStorage(definition.storage, dialect, [
 		"tables",
 		id,
@@ -155,9 +183,18 @@ function serializeColumn(id, definition, physicalName, dialect, options, diagnos
 		id,
 		"onUpdate"
 	], options, diagnostics) : void 0;
+	const columnDialect = definition.dialect ? encodeExtension(definition.dialect, dialect, [
+		"tables",
+		tableId,
+		"columns",
+		id,
+		"dialect"
+	], options, diagnostics) : void 0;
 	return {
+		kind: "column",
 		id,
 		physicalName,
+		ordinalPosition,
 		nullable: definition.nullable,
 		hasDefault: definition.hasDefault,
 		generated: definition.generated,
@@ -165,7 +202,8 @@ function serializeColumn(id, definition, physicalName, dialect, options, diagnos
 		...defaultValue === void 0 ? {} : { default: defaultValue },
 		...generatedColumn === void 0 ? {} : { generatedColumn },
 		...identity === void 0 ? {} : { identity },
-		...onUpdate === void 0 ? {} : { onUpdate }
+		...onUpdate === void 0 ? {} : { onUpdate },
+		...columnDialect === void 0 ? {} : { dialect: columnDialect }
 	};
 }
 function encodeStorage(storage, dialect, path, options, diagnostics) {
@@ -224,18 +262,48 @@ function encodeGenerated(value, dialect, path, options, diagnostics) {
 }
 function encodeIdentity(value, dialect, path, options, diagnostics) {
 	const extension = encodeExtension(value.dialect, dialect, [...path, "dialect"], options, diagnostics);
+	const identityOptions = {};
+	for (const [key, option] of Object.entries(value.options ?? {}).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+		const encoded = encodeValueFact(option, dialect, [
+			...path,
+			"options",
+			key
+		], options, diagnostics);
+		if (encoded !== void 0) identityOptions[key] = encoded;
+	}
 	return {
 		kind: "identity",
 		generation: value.generation,
+		options: identityOptions,
 		...extension === void 0 ? {} : { dialect: extension }
 	};
 }
-function serializeConstraint(id, constraint, table, tableIds, tablesById, dialect, options, diagnostics) {
-	const physicalName = constraint.physicalName ?? generatedSchemaObjectName(id);
+function encodeValueFact(value, dialect, path, options, diagnostics) {
+	if (isSchemaExpression(value)) {
+		const expression = encodeExpression(value, "default", dialect, path, options, diagnostics);
+		return expression === void 0 ? void 0 : {
+			kind: "expression",
+			expression
+		};
+	}
+	try {
+		return {
+			kind: "literal",
+			value: canonicalLiteral(value)
+		};
+	} catch (error) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: error instanceof Error ? error.message : String(error),
+			path
+		});
+		return;
+	}
+}
+function serializeConstraint(id, constraint, table, owner, tableIds, tablesById, dialect, options, diagnostics) {
 	const common = {
 		id,
-		kind: constraint.kind,
-		physicalName
+		physicalName: constraint.physicalName ?? generatedSchemaObjectName(id)
 	};
 	if (constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint") {
 		const columns = serializeColumns(constraint.columns, table, [
@@ -250,12 +318,15 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 		], options, diagnostics);
 		if (columns === void 0) return;
 		const timing = serializeTiming(constraint);
+		const backingIndex = serializeBackingIndex(constraint, owner);
 		if (constraint.kind === "unique-constraint") return {
 			...common,
 			kind: "unique-constraint",
 			columns,
 			nulls: constraint.nulls,
 			...timing,
+			...constraint.validated === void 0 ? {} : { validated: constraint.validated },
+			...backingIndex === void 0 ? {} : { backingIndex },
 			...extension === void 0 ? {} : { dialect: extension }
 		};
 		return {
@@ -263,6 +334,8 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 			kind: constraint.kind,
 			columns,
 			...timing,
+			...constraint.validated === void 0 ? {} : { validated: constraint.validated },
+			...backingIndex === void 0 ? {} : { backingIndex },
 			...extension === void 0 ? {} : { dialect: extension }
 		};
 	}
@@ -292,6 +365,7 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 			...constraint.onDelete === void 0 ? {} : { onDelete: constraint.onDelete },
 			...constraint.match === void 0 ? {} : { match: constraint.match },
 			...serializeTiming(constraint),
+			...constraint.validated === void 0 ? {} : { validated: constraint.validated },
 			...extension === void 0 ? {} : { dialect: extension }
 		};
 	}
@@ -312,6 +386,7 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 			kind: "check",
 			expression,
 			...serializeTiming(constraint),
+			...constraint.validated === void 0 ? {} : { validated: constraint.validated },
 			...extension === void 0 ? {} : { dialect: extension }
 		};
 	}
@@ -321,13 +396,20 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 		path: ["constraints", id]
 	});
 }
+function serializeBackingIndex(constraint, owner) {
+	return constraint.backingIndex === void 0 ? void 0 : {
+		kind: "index",
+		id: constraint.backingIndex,
+		owner
+	};
+}
 function serializeTiming(value) {
 	return {
 		...value.deferrable === void 0 ? {} : { deferrable: value.deferrable },
 		...value.initially === void 0 ? {} : { initially: value.initially }
 	};
 }
-function serializeColumns(columns, table, path, diagnostics) {
+function serializeColumns(columns, table, path, diagnostics, nonEmpty = true) {
 	const result = [];
 	for (const [index, column] of columns.entries()) {
 		if (!isColumnReference(column)) {
@@ -348,7 +430,7 @@ function serializeColumns(columns, table, path, diagnostics) {
 		}
 		result.push(column.fieldName);
 	}
-	return result.length === columns.length && result.length > 0 ? result : void 0;
+	return result.length === columns.length && (!nonEmpty || result.length > 0) ? result : void 0;
 }
 function resolveForeignKeyTarget(constraint, tableIds, tablesById, path, diagnostics) {
 	let target;
@@ -374,14 +456,17 @@ function resolveForeignKeyTarget(constraint, tableIds, tablesById, path, diagnos
 	const targetColumns = serializeColumns(target.columns, target.table, [...path, "columns"], diagnostics);
 	if (targetColumns === void 0) return;
 	return {
-		table: targetId,
+		table: {
+			kind: "table",
+			id: targetId
+		},
 		columns: targetColumns
 	};
 }
-function serializeIndex(id, indexMetadata, table, dialect, options, diagnostics) {
+function serializeIndex(id, indexMetadata, table, owner, dialect, options, diagnostics) {
 	const terms = [];
 	for (const [termIndex, term] of indexMetadata.terms.entries()) {
-		const serialized = serializeIndexTerm(term, table, dialect, [
+		const serialized = serializeIndexTerm(term, indexMetadata.termOptions?.[termIndex], table, dialect, termIndex + 1, [
 			"indexes",
 			id,
 			"terms",
@@ -398,12 +483,21 @@ function serializeIndex(id, indexMetadata, table, dialect, options, diagnostics)
 		"indexes",
 		id,
 		"includedColumns"
-	], diagnostics);
+	], diagnostics, false);
 	const extension = encodeExtension(indexMetadata.dialect, dialect, [
 		"indexes",
 		id,
 		"dialect"
 	], options, diagnostics);
+	if (indexMetadata.termOptions !== void 0 && indexMetadata.termOptions.length > indexMetadata.terms.length) diagnostics.push({
+		code: "invalid-schema",
+		message: "Index termOptions cannot contain entries without matching terms",
+		path: [
+			"indexes",
+			id,
+			"termOptions"
+		]
+	});
 	if (terms.length !== indexMetadata.terms.length || indexMetadata.includedColumns !== void 0 && includedColumns === void 0) return;
 	return {
 		id,
@@ -414,20 +508,42 @@ function serializeIndex(id, indexMetadata, table, dialect, options, diagnostics)
 		candidateKey: indexMetadata.candidateKey,
 		...predicate === void 0 ? {} : { predicate },
 		...includedColumns === void 0 ? {} : { includedColumns },
+		...indexMetadata.backingConstraint === void 0 ? {} : { backingConstraint: {
+			kind: "constraint",
+			id: indexMetadata.backingConstraint,
+			owner
+		} },
+		...indexMetadata.method === void 0 ? {} : { method: indexMetadata.method },
 		...extension === void 0 ? {} : { dialect: extension }
 	};
 }
-function serializeIndexTerm(term, table, dialect, path, options, diagnostics) {
+function serializeIndexTerm(term, termOptions, table, dialect, position, path, options, diagnostics) {
 	if (isOrderTerm(term)) {
 		const expression = serializeIndexTermExpression(term.expression, table, dialect, [...path, "expression"], options, diagnostics);
-		return expression === void 0 ? void 0 : {
-			kind: "order",
-			expression,
+		const termMetadata = expression === void 0 ? void 0 : serializeIndexTermOptions(termOptions, dialect, path, options, diagnostics);
+		return expression === void 0 || termMetadata === void 0 ? void 0 : {
+			...expression,
+			position,
 			...term.direction === void 0 ? {} : { direction: term.direction },
-			...term.nulls === void 0 ? {} : { nulls: term.nulls }
+			...term.nulls === void 0 ? {} : { nulls: term.nulls },
+			...termMetadata
 		};
 	}
-	return serializeIndexTermExpression(term, table, dialect, path, options, diagnostics);
+	const expression = serializeIndexTermExpression(term, table, dialect, path, options, diagnostics);
+	const termMetadata = expression === void 0 ? void 0 : serializeIndexTermOptions(termOptions, dialect, path, options, diagnostics);
+	return expression === void 0 || termMetadata === void 0 ? void 0 : {
+		...expression,
+		position,
+		...termMetadata
+	};
+}
+function serializeIndexTermOptions(value, dialect, path, options, diagnostics) {
+	if (value === void 0) return {};
+	const prefixLength = value.prefixLength === void 0 ? void 0 : encodeValueFact(value.prefixLength, dialect, [...path, "prefixLength"], options, diagnostics);
+	return value.prefixLength !== void 0 && prefixLength === void 0 ? void 0 : {
+		...prefixLength === void 0 ? {} : { prefixLength },
+		...value.operatorClass === void 0 ? {} : { operatorClass: value.operatorClass }
+	};
 }
 function serializeIndexTermExpression(expression, table, dialect, path, options, diagnostics) {
 	if (isColumnReference(expression)) {
@@ -527,7 +643,7 @@ function encodeExtension(extension, dialect, path, options, diagnostics) {
 		return;
 	}
 	const data = {};
-	for (const [key, value] of Object.entries(extension)) if (key !== "dialect") data[key] = value;
+	for (const [key, value] of Object.entries(extension)) if (key !== "dialect") setOwn(data, key, value);
 	try {
 		return {
 			dialect: extension.dialect,
@@ -552,5 +668,33 @@ function isSchemaRoot(value) {
 function compareId(left, right) {
 	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
 }
+function setOwn(target, key, value) {
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
+function namespaceFor(dialect, name) {
+	return {
+		kind: dialect === "postgresql" ? "postgres-schema" : dialect === "sqlite" ? "sqlite-database" : dialect === "mysql" ? "mysql-database" : "generic",
+		name
+	};
+}
+function capabilitiesFor(dialect) {
+	return {
+		generatedColumns: dialect !== "neutral",
+		identityMetadata: dialect !== "neutral",
+		checkConstraints: true,
+		checkConstraintEnforcement: "unknown",
+		expressionDecompilation: false,
+		indexExpressions: true,
+		indexPredicates: true,
+		indexIncludedColumns: dialect === "postgresql",
+		namespaces: dialect !== "neutral",
+		visibility: "complete"
+	};
+}
 //#endregion
 export { fingerprintSchemaSnapshot as a, encodeSnapshot as i, createSchemaSnapshot as n, serializeSchema as o, encodeSchemaSnapshot as r, tryCreateSchemaSnapshot as s, SnapshotSerializationError as t };

package/dist/serialize-Du2UPZMt.d.mts

@@ -0,0 +1,92 @@
+import { B as CompleteSchemaSnapshot, T as SnapshotJsonValue, V as CompleteSchemaSnapshotInput, Y as CompleteSnapshotDecodeResult, Yi as Schema, f as SnapshotDiagnostic, i as SchemaSnapshotInput, ji as SchemaDialect, l as SnapshotCreateResult, n as SchemaSnapshot, r as SchemaSnapshotAdapter, u as SnapshotDecodeResult } from "./types-Dqr4o2I1.mjs";
+//#region src/snapshot/canonical.d.ts
+/** Error raised when a value cannot cross the canonical JSON boundary. */
+declare class SnapshotCanonicalError extends TypeError {
+  readonly path: readonly (string | number)[];
+  constructor(message: string, path?: readonly (string | number)[]);
+}
+/** Convert a JavaScript value to the explicit JSON-safe snapshot domain. */
+declare function toSnapshotJsonValue(value: unknown, path?: readonly (string | number)[], seen?: WeakSet<object>): SnapshotJsonValue;
+/** Render a JSON-safe value with deterministic scalar and object handling. */
+declare function canonicalJson(value: SnapshotJsonValue): string;
+/** Canonical JSON for a schema snapshot after fixed-order reconstruction. */
+declare function encodeCanonicalSnapshot(snapshot: SchemaSnapshot): string;
+/**
+ * Compute a small deterministic content fingerprint for cache keys and diagnostics. It is
+ * deliberately not an entity identity, signature, or migration lineage.
+ */
+declare function schemaSnapshotFingerprint(snapshot: SchemaSnapshotInput | string): string;
+//#endregion
+//#region src/snapshot/complete.d.ts
+/** Error raised by throwing APIs after collecting strict v1 diagnostics. */
+declare class CompleteSnapshotValidationError extends TypeError {
+  readonly name: string;
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+  readonly issues: readonly SnapshotDiagnostic[];
+  constructor(diagnostics: readonly SnapshotDiagnostic[]);
+}
+/** Decode and strictly validate a complete Snapshot v1 JSON value. */
+declare function decodeCompleteSchemaSnapshot(input: string | unknown): CompleteSnapshotDecodeResult;
+/** Validate a complete snapshot and throw one structured error on failure. */
+declare function assertCompleteSchemaSnapshot(input: CompleteSchemaSnapshotInput | string): CompleteSchemaSnapshot;
+/** Return a fixed-order, deeply immutable complete snapshot. */
+declare function canonicalizeCompleteSchemaSnapshot(input: CompleteSchemaSnapshotInput): CompleteSchemaSnapshot;
+/** Encode a complete snapshot with deterministic property and array order. */
+declare function encodeCompleteSchemaSnapshot(snapshot: CompleteSchemaSnapshot): string;
+/** Compute the deterministic content fingerprint for a complete Snapshot v1. */
+declare function completeSchemaSnapshotFingerprint(snapshot: CompleteSchemaSnapshotInput | string): string;
+/** Numbered aliases for tooling that prefers explicit Snapshot v1 names. */
+declare const decodeSchemaSnapshotV1: typeof decodeCompleteSchemaSnapshot;
+declare const assertSchemaSnapshotV1: typeof assertCompleteSchemaSnapshot;
+declare const encodeSchemaSnapshotV1: typeof encodeCompleteSchemaSnapshot;
+declare const canonicalizeSchemaSnapshotV1: typeof canonicalizeCompleteSchemaSnapshot;
+declare const schemaSnapshotV1Fingerprint: typeof completeSchemaSnapshotFingerprint;
+declare const decodeCompleteSnapshot: typeof decodeCompleteSchemaSnapshot;
+declare const assertCompleteSnapshot: typeof assertCompleteSchemaSnapshot;
+declare const encodeCompleteSnapshot: typeof encodeCompleteSchemaSnapshot;
+declare const fingerprintCompleteSchemaSnapshot: typeof completeSchemaSnapshotFingerprint;
+//#endregion
+//#region src/snapshot/decode.d.ts
+/** Error raised by throwing snapshot APIs after collecting diagnostics. */
+declare class SnapshotValidationError extends CompleteSnapshotValidationError {
+  readonly name: string;
+}
+/** Decode and strictly validate the canonical Snapshot v1 JSON value. */
+declare function decodeSchemaSnapshot(input: string | unknown): SnapshotDecodeResult;
+/** Validate a Snapshot v1 value and throw one structured error if it is malformed. */
+declare function assertSchemaSnapshot(input: SchemaSnapshotInput | string): SchemaSnapshot;
+/** Return a fixed-order, deeply immutable copy of a valid Snapshot v1 value. */
+declare function canonicalizeSchemaSnapshot(input: SchemaSnapshotInput): SchemaSnapshot;
+//#endregion
+//#region src/snapshot/serialize.d.ts
+/** Error raised when a live Qubu schema cannot be represented as a snapshot. */
+declare class SnapshotSerializationError extends SnapshotValidationError {
+  readonly name = "SnapshotSerializationError";
+}
+/** Options for the schema traversal and a dialect adapter. */
+interface SchemaSnapshotOptions {
+  readonly adapter?: SchemaSnapshotAdapter;
+  readonly dialect?: SchemaDialect;
+  /** Explicit hook overrides retained for custom tooling integrations. */
+  readonly expressionEncoder?: SchemaDialect["schema"]["encodeExpression"];
+  readonly storageEncoder?: SchemaDialect["schema"]["encodeStorage"];
+  readonly extensionEncoder?: SchemaDialect["schema"]["encodeDialectExtension"];
+  readonly namingPolicy?: {
+    readonly name: string;
+    readonly version?: number;
+  };
+}
+/** Create an immutable Snapshot v1 value from a live schema. */
+declare function createSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SchemaSnapshotOptions): SchemaSnapshot;
+/** Non-throwing form of {@link createSchemaSnapshot}. */
+declare function tryCreateSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SchemaSnapshotOptions): SnapshotCreateResult;
+/** Encode a valid Snapshot v1 value using canonical JSON. */
+declare function encodeSchemaSnapshot(snapshot: SchemaSnapshot): string;
+/** Alias used by tooling packages that call the operation serialization. */
+declare const serializeSchema: typeof createSchemaSnapshot;
+/** Alias for the canonical snapshot encoder. */
+declare const encodeSnapshot: typeof encodeSchemaSnapshot;
+/** Alias for the canonical snapshot fingerprint helper. */
+declare const fingerprintSchemaSnapshot: typeof schemaSnapshotFingerprint;
+//#endregion
+export { encodeCanonicalSnapshot as A, encodeCompleteSchemaSnapshot as C, schemaSnapshotV1Fingerprint as D, fingerprintCompleteSchemaSnapshot as E, toSnapshotJsonValue as M, SnapshotCanonicalError as O, decodeSchemaSnapshotV1 as S, encodeSchemaSnapshotV1 as T, canonicalizeCompleteSchemaSnapshot as _, encodeSnapshot as a, decodeCompleteSchemaSnapshot as b, tryCreateSchemaSnapshot as c, canonicalizeSchemaSnapshot as d, decodeSchemaSnapshot as f, assertSchemaSnapshotV1 as g, assertCompleteSnapshot as h, encodeSchemaSnapshot as i, schemaSnapshotFingerprint as j, canonicalJson as k, SnapshotValidationError as l, assertCompleteSchemaSnapshot as m, SnapshotSerializationError as n, fingerprintSchemaSnapshot as o, CompleteSnapshotValidationError as p, createSchemaSnapshot as r, serializeSchema as s, SchemaSnapshotOptions as t, assertSchemaSnapshot as u, canonicalizeSchemaSnapshotV1 as v, encodeCompleteSnapshot as w, decodeCompleteSnapshot as x, completeSchemaSnapshotFingerprint as y };

package/dist/snapshot/mysql.d.mts

@@ -1,12 +1,12 @@
-import { Tr as SchemaDialect, Ur as Schema, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-C0VkiwpR.mjs";
-import { t as SchemaSnapshotOptions } from "../serialize-CEIIlWhC.mjs";
+import { Yi as Schema, ji as SchemaDialect, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-Dqr4o2I1.mjs";
+import { t as SchemaSnapshotOptions } from "../serialize-Du2UPZMt.mjs";
 //#region src/snapshot/mysql.d.ts
-/** MySQL's v1 snapshot extension identity. */
+/** MySQL's snapshot dialect-extension identity. */
 declare const mysqlSnapshotDialect: SnapshotDialect;
 /** MySQL's query dialect plus its schema metadata behavior. */
-declare const mysqlSchemaDialect: SchemaDialect<"json" | "row-locking">;
+declare const mysqlSchemaDialect: SchemaDialect<"json" | "on-duplicate-key-update" | "row-locking">;
 /** Snapshot adapter retaining the historical adapter-shaped entry point. */
-declare const mysqlSnapshotAdapter: SchemaSnapshotAdapter<"json" | "row-locking">;
+declare const mysqlSnapshotAdapter: SchemaSnapshotAdapter<"json" | "on-duplicate-key-update" | "row-locking">;
 /** Create a canonical MySQL schema snapshot. */
 declare function createSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: MysqlSnapshotOptions): SchemaSnapshot;
 /** Return MySQL capability diagnostics without throwing. */