qubu 0.5.0 → 0.6.0

package/dist/index-C-480HmV.d.mts

@@ -1,146 +0,0 @@
-import { T as SnapshotJsonValue, Tr as SchemaDialect, Ur as Schema, f as SnapshotDiagnostic, i as SchemaSnapshotInput, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter, u as SnapshotDecodeResult } from "./types-C0VkiwpR.mjs";
-import { n as CompleteSchemaSnapshotInput, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult } from "./complete-types-CY0KbzNw.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 v2 diagnostics. */
-declare class CompleteSnapshotValidationError extends TypeError {
-  readonly name = "CompleteSnapshotValidationError";
-  readonly diagnostics: readonly SnapshotDiagnostic[];
-  readonly issues: readonly SnapshotDiagnostic[];
-  constructor(diagnostics: readonly SnapshotDiagnostic[]);
-}
-/** Decode and strictly validate a complete Snapshot v2 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 v2. */
-declare function completeSchemaSnapshotFingerprint(snapshot: CompleteSchemaSnapshotInput | string): string;
-/** Numbered aliases for tooling that keeps v1 and v2 side by side. */
-declare const decodeSchemaSnapshotV2: typeof decodeCompleteSchemaSnapshot;
-declare const assertSchemaSnapshotV2: typeof assertCompleteSchemaSnapshot;
-declare const encodeSchemaSnapshotV2: typeof encodeCompleteSchemaSnapshot;
-declare const canonicalizeSchemaSnapshotV2: typeof canonicalizeCompleteSchemaSnapshot;
-declare const schemaSnapshotV2Fingerprint: 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 TypeError {
-  readonly name: string;
-  readonly diagnostics: readonly SnapshotDiagnostic[];
-  readonly issues: readonly SnapshotDiagnostic[];
-  constructor(diagnostics: readonly SnapshotDiagnostic[]);
-}
-/** Decode and strictly validate a JSON string or parsed snapshot value. */
-declare function decodeSchemaSnapshot(input: string | unknown): SnapshotDecodeResult;
-/** Validate a snapshot 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. */
-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 neutral traversal and a future 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 a neutral or adapter-owned immutable snapshot 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 using fixed property order and 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
-//#region src/snapshot/postgres.d.ts
-/** PostgreSQL's v1 snapshot extension identity. */
-declare const postgresSnapshotDialect: SnapshotDialect;
-/** PostgreSQL's query dialect plus its schema metadata behavior. */
-declare const postgresSchemaDialect: SchemaDialect<"ilike" | "json" | "on-conflict" | "row-locking">;
-/** Snapshot adapter retaining the historical adapter-shaped entry point. */
-declare const postgresSnapshotAdapter: SchemaSnapshotAdapter<"ilike" | "json" | "on-conflict" | "row-locking">;
-/** Create a canonical PostgreSQL schema snapshot. */
-declare function createPostgresSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: PostgresSnapshotOptions): SchemaSnapshot;
-/** Return PostgreSQL capability diagnostics without throwing. */
-declare function tryCreatePostgresSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: PostgresSnapshotOptions): SnapshotCreateResult;
-/** Options accepted by the PostgreSQL snapshot convenience functions. */
-type PostgresSnapshotOptions = Omit<SchemaSnapshotOptions, "adapter" | "dialect">;
-//#endregion
-//#region src/snapshot/sqlite.d.ts
-/** SQLite's v1 snapshot extension identity. */
-declare const sqliteSnapshotDialect: SnapshotDialect;
-/** SQLite's five declared-type affinity categories. */
-type SqliteStorageAffinity = "blob" | "integer" | "numeric" | "real" | "text";
-/**
- * Resolve SQLite's declared-type affinity without changing the declaration. SQLite applies these
- * ordered substring rules at table creation time; the returned affinity is useful metadata, not a
- * replacement for the exact type.
- */
-declare function sqliteStorageAffinity(declaration: string): SqliteStorageAffinity;
-/** SQLite's query dialect plus its schema metadata behavior. */
-declare const sqliteSchemaDialect: SchemaDialect<"json" | "on-conflict">;
-/** Snapshot adapter retaining the historical adapter-shaped entry point. */
-declare const sqliteSnapshotAdapter: SchemaSnapshotAdapter<"json" | "on-conflict">;
-/** Create a canonical SQLite schema snapshot. */
-declare function createSqliteSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SqliteSnapshotOptions): SchemaSnapshot;
-/** Return SQLite capability diagnostics without throwing. */
-declare function tryCreateSqliteSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SqliteSnapshotOptions): SnapshotCreateResult;
-/** Options accepted by the SQLite snapshot convenience functions. */
-type SqliteSnapshotOptions = Omit<SchemaSnapshotOptions, "adapter" | "dialect">;
-//#endregion
-//#region src/snapshot/mysql.d.ts
-/** MySQL's v1 snapshot extension identity. */
-declare const mysqlSnapshotDialect: SnapshotDialect;
-/** MySQL's query dialect plus its schema metadata behavior. */
-declare const mysqlSchemaDialect: SchemaDialect<"json" | "row-locking">;
-/** Snapshot adapter retaining the historical adapter-shaped entry point. */
-declare const mysqlSnapshotAdapter: SchemaSnapshotAdapter<"json" | "row-locking">;
-/** Create a canonical MySQL schema snapshot. */
-declare function createMysqlSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: MysqlSnapshotOptions): SchemaSnapshot;
-/** Return MySQL capability diagnostics without throwing. */
-declare function tryCreateMysqlSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: MysqlSnapshotOptions): SnapshotCreateResult;
-/** Options accepted by the MySQL snapshot convenience functions. */
-type MysqlSnapshotOptions = Omit<SchemaSnapshotOptions, "adapter" | "dialect">;
-//#endregion
-export { assertSchemaSnapshot as A, decodeCompleteSchemaSnapshot as B, createSchemaSnapshot as C, serializeSchema as D, fingerprintSchemaSnapshot as E, assertCompleteSnapshot as F, encodeSchemaSnapshotV2 as G, decodeSchemaSnapshotV2 as H, assertSchemaSnapshotV2 as I, SnapshotCanonicalError as J, fingerprintCompleteSchemaSnapshot as K, canonicalizeCompleteSchemaSnapshot as L, decodeSchemaSnapshot as M, CompleteSnapshotValidationError as N, tryCreateSchemaSnapshot as O, assertCompleteSchemaSnapshot as P, toSnapshotJsonValue as Q, canonicalizeSchemaSnapshotV2 as R, SnapshotSerializationError as S, encodeSnapshot as T, encodeCompleteSchemaSnapshot as U, decodeCompleteSnapshot as V, encodeCompleteSnapshot as W, encodeCanonicalSnapshot as X, canonicalJson as Y, schemaSnapshotFingerprint as Z, postgresSchemaDialect as _, mysqlSnapshotDialect as a, tryCreatePostgresSchemaSnapshot as b, SqliteStorageAffinity as c, sqliteSnapshotAdapter as d, sqliteSnapshotDialect as f, createPostgresSchemaSnapshot as g, PostgresSnapshotOptions as h, mysqlSnapshotAdapter as i, canonicalizeSchemaSnapshot as j, SnapshotValidationError as k, createSqliteSchemaSnapshot as l, tryCreateSqliteSchemaSnapshot as m, createMysqlSchemaSnapshot as n, tryCreateMysqlSchemaSnapshot as o, sqliteStorageAffinity as p, schemaSnapshotV2Fingerprint as q, mysqlSchemaDialect as r, SqliteSnapshotOptions as s, MysqlSnapshotOptions as t, sqliteSchemaDialect as u, postgresSnapshotAdapter as v, encodeSchemaSnapshot as w, SchemaSnapshotOptions as x, postgresSnapshotDialect as y, completeSchemaSnapshotFingerprint as z };

package/dist/registry-BGqa05et.mjs

@@ -1,461 +0,0 @@
-import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
-import { G as markSchemaExpression, M as dialectMismatchDiagnostic, N as freezeSchemaMetadata, U as makeSchemaExpression, V as isSchemaExpression, r as isColumnReference, z as snakeCaseIdentifier } from "./column-DmazTL67.mjs";
-import { n as isValueExpression } from "./value-BEEj_Ayd.mjs";
-//#region src/schema/indexes.ts
-/**
-* Validate portable and dialect-owned index facts for one target adapter. Unsupported features are
-* reported as data so a serializer can aggregate diagnostics instead of failing during traversal
-* with an opaque exception.
-*/
-function validateIndexDialect(indexMetadata, dialect, path = ["index"]) {
-	const diagnostics = [];
-	const extension = indexMetadata.dialect;
-	if (extension !== void 0) {
-		const mismatch = dialectMismatchDiagnostic(extension, dialect, [...path, "dialect"]);
-		if (mismatch !== void 0) diagnostics.push(mismatch);
-	}
-	if ((dialect === "sqlite" || dialect === "mysql") && indexMetadata.includedColumns !== void 0 && indexMetadata.includedColumns.length > 0) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: `${dialect} indexes do not support included columns`,
-		path: [...path, "includedColumns"],
-		dialect
-	});
-	const mysqlKeyBlockSize = extension?.dialect === "mysql" ? extension.keyBlockSize : void 0;
-	if (mysqlKeyBlockSize !== void 0 && (!Number.isInteger(mysqlKeyBlockSize) || mysqlKeyBlockSize <= 0)) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "MySQL index keyBlockSize must be a positive integer",
-		path: [
-			...path,
-			"dialect",
-			"keyBlockSize"
-		],
-		dialect
-	});
-	return Object.freeze(diagnostics);
-}
-/** Declare a portable column or expression index. */
-function index(terms, options) {
-	const resolvedOptions = options ?? {};
-	const candidateKey = resolvedOptions.unique === true && resolvedOptions.where === void 0 && terms.every((term) => {
-		return ("orderKind" in term ? term.expression : term).expressionKind === "column";
-	});
-	return Object.freeze({
-		kind: "index",
-		terms: Object.freeze([...terms]),
-		unique: resolvedOptions.unique === true,
-		predicate: resolvedOptions.where,
-		...resolvedOptions.include !== void 0 ? { includedColumns: Object.freeze([...resolvedOptions.include]) } : {},
-		...resolvedOptions.physicalName !== void 0 ? { physicalName: resolvedOptions.physicalName } : {},
-		...resolvedOptions.dialect !== void 0 ? { dialect: freezeSchemaMetadata(resolvedOptions.dialect) } : {},
-		candidateKey
-	});
-}
-//#endregion
-//#region src/schema/expressions.ts
-/** Error raised before a schema expression can become persisted SQL. */
-var SchemaExpressionError = class extends TypeError {
-	code;
-	mode;
-	constructor(code, message, mode) {
-		super(message);
-		this.name = "SchemaExpressionError";
-		this.code = code;
-		this.mode = mode;
-	}
-};
-/**
-* Normalize only line endings. Whitespace, quoting, and every other byte of a raw schema expression
-* remain under the extension author's control.
-*/
-function normalizeSchemaSql(sql) {
-	return sql.replace(/\r\n?/g, "\n");
-}
-function schemaExpression(expression) {
-	return markSchemaExpression(expression);
-}
-/**
-* Define an extension with the restricted schema context. This is the typed alternative to
-* {@link unsafeSchemaSql} for deterministic custom syntax.
-*/
-function defineSchemaExpression(kind, render) {
-	return makeSchemaExpression(kind, (context) => render(context));
-}
-function unsafeSchemaSql(dialectOrOptions, sql) {
-	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
-	const source = typeof dialectOrOptions === "string" ? sql : dialectOrOptions.sql;
-	if (!dialect) throw new TypeError("unsafeSchemaSql() requires a dialect tag");
-	if (source === void 0) throw new TypeError("unsafeSchemaSql() requires SQL text");
-	const normalized = normalizeSchemaSql(source);
-	const expression = makeSchemaExpression("unsafe", (context) => context.append(normalized));
-	return Object.freeze({
-		...expression,
-		schemaSqlDialect: dialect,
-		schemaSql: normalized
-	});
-}
-/** Identify a dialect-tagged raw schema expression. */
-function isUnsafeSchemaSql(value) {
-	return isSchemaExpression(value) && value.expressionKind === "unsafe" && typeof value.schemaSqlDialect === "string" && typeof value.schemaSql === "string";
-}
-function renderSchemaExpression(expression, optionsOrMode, dialectOption) {
-	const options = typeof optionsOrMode === "string" ? {
-		mode: optionsOrMode,
-		dialect: dialectOption
-	} : optionsOrMode;
-	const dialect = options.dialect ?? standardDialect();
-	if (!isSchemaExpression(expression)) throw new SchemaExpressionError("not-deterministic", "Only branded deterministic expressions can be rendered as schema SQL", options.mode);
-	assertSupportedExpression(expression, options.mode);
-	let text = "";
-	const context = {
-		dialect,
-		projectionMode: "result",
-		schemaMode: options.mode,
-		append(value) {
-			text += value;
-		},
-		parameter() {
-			throw new SchemaExpressionError("parameter", "Schema expressions cannot render query parameters", options.mode);
-		},
-		literal(value) {
-			text += renderSchemaLiteral(dialect, value, options.mode);
-		},
-		renderColumnReference(columnName) {
-			if (options.mode === "default") throw new SchemaExpressionError("column-not-allowed", "Default expressions cannot reference table columns", options.mode);
-			text += dialect.quoteIdentifier(columnName);
-		},
-		render(part) {
-			renderSchemaPart(context, part, options.mode);
-		},
-		renderRelation() {
-			throw new SchemaExpressionError("unsupported-expression", "Schema expressions cannot contain subqueries", options.mode);
-		}
-	};
-	renderSchemaPart(context, expression, options.mode);
-	return Object.freeze({
-		text,
-		parameters: Object.freeze([])
-	});
-}
-/** Convenience form for callers that only need the SQL text. */
-function renderSchemaSql(expression, options) {
-	return renderSchemaExpression(expression, options).text;
-}
-function renderSchemaPart(context, part, mode) {
-	if (isValueExpression(part)) {
-		context.literal(part.value);
-		return;
-	}
-	if (isColumnReference(part)) {
-		context.renderColumnReference(part.columnName);
-		return;
-	}
-	if (isUnsafeSchemaSql(part)) {
-		if (part.schemaSqlDialect !== context.dialect.name) throw new SchemaExpressionError("dialect-mismatch", `Schema SQL is tagged for "${part.schemaSqlDialect}" but rendered for "${context.dialect.name}"`, mode);
-		context.append(part.schemaSql);
-		return;
-	}
-	if (!isSchemaExpression(part)) throw new SchemaExpressionError("not-deterministic", "Schema expressions may only compose branded expressions, columns, and literals", mode);
-	assertSupportedExpression(part, mode);
-	part.render(context);
-}
-function assertSupportedExpression(expression, mode) {
-	if (expression.expressionKind === "subquery" || expression.expressionCategory) throw new SchemaExpressionError("unsupported-expression", "Aggregates, windows, and subqueries are not valid schema expressions", mode);
-}
-function renderSchemaLiteral(dialect, value, mode) {
-	if (dialect.renderSchemaLiteral) {
-		const rendered = dialect.renderSchemaLiteral(value);
-		if (typeof rendered !== "string" || rendered.includes("?")) throw new SchemaExpressionError("invalid-literal", "A schema literal renderer must return parameter-free SQL text", mode);
-		return rendered;
-	}
-	if (value === null) return "NULL";
-	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
-	if (typeof value === "bigint") return String(value);
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new SchemaExpressionError("unsupported-value", "Schema literals require finite numbers", mode);
-		return Object.is(value, -0) ? "0" : String(value);
-	}
-	throw new SchemaExpressionError("unsupported-value", `Unsupported schema literal type: ${value === void 0 ? "undefined" : typeof value}`, mode);
-}
-//#endregion
-//#region src/schema/constraints.ts
-/**
-* Validate one constraint against a schema adapter dialect. This is kept separate from construction
-* because the same declaration can be inspected for more than one target dialect before a
-* serializer is selected.
-*/
-function validateConstraintDialect(constraint, dialect, path = ["constraint"]) {
-	const diagnostics = [];
-	const extension = constraint.dialect;
-	if (extension !== void 0) {
-		const mismatch = dialectMismatchDiagnostic(extension, dialect, [...path, "dialect"]);
-		if (mismatch !== void 0) diagnostics.push(mismatch);
-		if (extension.dialect === "postgresql" && "notValid" in extension && extension.notValid === true && (constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint")) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL NOT VALID is not supported for key constraints",
-			path: [
-				...path,
-				"dialect",
-				"notValid"
-			],
-			dialect
-		});
-		if (extension.dialect === "sqlite" && "onConflict" in extension && extension.onConflict !== void 0 && constraint.kind === "foreign-key") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "SQLite conflict policies do not apply to foreign keys",
-			path: [
-				...path,
-				"dialect",
-				"onConflict"
-			],
-			dialect
-		});
-	}
-	if (constraint.kind === "foreign-key" && constraint.match === "partial" && dialect === "mysql") diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "MySQL does not support MATCH PARTIAL foreign keys",
-		path: [...path, "match"],
-		dialect
-	});
-	if (constraint.kind === "foreign-key" && constraint.deferrable === true && dialect === "mysql") diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "MySQL foreign keys cannot be declared DEFERRABLE",
-		path: [...path, "deferrable"],
-		dialect
-	});
-	if (constraint.initially !== void 0 && constraint.deferrable !== true) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "An initial constraint timing requires deferrable: true",
-		path: [...path, "initially"],
-		dialect
-	});
-	return Object.freeze(diagnostics);
-}
-function primaryKey(...columnsAndOptions) {
-	const last = columnsAndOptions.at(-1);
-	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
-	return freezeConstraint("primary-key", options ? columnsAndOptions.slice(0, -1) : columnsAndOptions, options);
-}
-function unique(...columnsAndOptions) {
-	const last = columnsAndOptions.at(-1);
-	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
-	return freezeConstraint("unique", options ? columnsAndOptions.slice(0, -1) : columnsAndOptions, options);
-}
-function uniqueConstraint(...columnsAndOptions) {
-	const last = columnsAndOptions.at(-1);
-	const options = last && typeof last === "object" && !("expressionKind" in last) ? last : void 0;
-	const columns = options ? columnsAndOptions.slice(0, -1) : columnsAndOptions;
-	const resolvedOptions = options ?? {};
-	return freezeConstraint("unique-constraint", columns, resolvedOptions, resolvedOptions.nulls ?? "distinct");
-}
-/** Pair a table with the exact columns targeted by a foreign key. */
-function references(table, ...columns) {
-	return Object.freeze({
-		table,
-		columns: Object.freeze([...columns])
-	});
-}
-/** Declare a single-column or composite foreign key. */
-function foreignKey(columns, target, options) {
-	return freezeConstraint("foreign-key", columns, options, target);
-}
-/**
-* Reconstruct a foreign key proved by database catalog metadata.
-*
-* @remarks
-*   Use this helper for generated or introspection-owned declarations when one or both native SQL
-*   domains are unresolved. It accepts unresolved domains, but still rejects known domain
-*   mismatches, unequal tuple arity, and local columns from different sources. The enclosing
-*   `table()` declaration continues to verify target-column ownership and candidate-key metadata.
-*   Resolved targets also receive runtime shape, ownership, and arity checks. The returned value
-*   serializes as an ordinary foreign-key constraint.
-*/
-function catalogForeignKey(columns, target, options) {
-	assertCatalogForeignKeyColumns(columns, "local");
-	return freezeConstraint("foreign-key", columns, options, validateCatalogForeignKeyTargetInput(target, columns.length));
-}
-/** Declare a boolean table invariant. */
-function check(expression, options) {
-	return freezeConstraint("check", void 0, options, expression);
-}
-/**
-* Reconstruct a boolean check from opaque SQL recovered from a database catalog.
-*
-* @remarks
-*   This helper records catalog origin as a narrow type-level proof. It gives the opaque expression
-*   the {@link SqlBoolean} semantic type without changing the ordinary {@link check} contract. Qubu
-*   does not parse or infer dependencies from the SQL. It preserves the text apart from normalizing
-*   line endings and retains the dialect tag in serialized schema metadata.
-*/
-function catalogCheck(input, options) {
-	assertCatalogCheckSql(input);
-	return freezeConstraint("check", void 0, options, unsafeSchemaSql(input.dialect, input.sql));
-}
-function assertCatalogCheckSql(value) {
-	if (typeof value !== "object" || value === null) throw new TypeError("catalogCheck() requires dialect-tagged SQL data");
-	const input = value;
-	if (input.dialect !== "postgresql" && input.dialect !== "sqlite" && input.dialect !== "mysql") throw new TypeError(`catalogCheck() requires a supported catalog dialect, received "${String(input.dialect)}"`);
-	if (typeof input.sql !== "string" || input.sql.trim().length === 0) throw new TypeError("catalogCheck() requires non-empty SQL text");
-}
-function assertCatalogForeignKeyColumns(value, side) {
-	if (!Array.isArray(value) || value.length === 0) throw new TypeError(`catalogForeignKey() requires at least one ${side} column`);
-	if (!value.every(isColumnReference)) throw new TypeError(`catalogForeignKey() requires ${side} columns to be column references`);
-}
-function validateCatalogForeignKeyTargetInput(value, localArity) {
-	return typeof value === "function" ? () => validateCatalogForeignKeyTarget(value(), localArity) : validateCatalogForeignKeyTarget(value, localArity);
-}
-function validateCatalogForeignKeyTarget(value, localArity) {
-	if (typeof value !== "object" || value === null) throw new TypeError("catalogForeignKey() requires a foreign-key target");
-	const target = value;
-	assertCatalogForeignKeyColumns(target.columns, "target");
-	if (target.columns.length !== localArity) throw new TypeError(`catalogForeignKey() column arity differs: ${localArity} local and ${target.columns.length} target`);
-	const table = target.table;
-	if (typeof table !== "object" || table === null || typeof table.columns !== "object" || table.columns === null) throw new TypeError("catalogForeignKey() target must reference a table");
-	for (const column of target.columns) if (table.columns[column.fieldName] !== column) throw new TypeError(`catalogForeignKey() target column "${column.fieldName}" does not belong to its table`);
-	return target;
-}
-function freezeConstraint(kind, columns, options, extra) {
-	const value = { kind };
-	const optionValues = options;
-	if (columns !== void 0) value.columns = Object.freeze([...columns]);
-	if (kind === "check") value.expression = extra;
-	else if (kind === "foreign-key") value.target = extra;
-	else if (kind === "unique-constraint") value.nulls = extra;
-	if (optionValues?.physicalName !== void 0) value.physicalName = optionValues.physicalName;
-	if (optionValues?.dialect !== void 0) value.dialect = freezeSchemaMetadata(optionValues.dialect);
-	if (optionValues?.deferrable !== void 0) value.deferrable = optionValues.deferrable;
-	if (optionValues?.initially !== void 0) value.initially = optionValues.initially;
-	if (kind === "foreign-key") {
-		if (optionValues?.onUpdate !== void 0) value.onUpdate = optionValues.onUpdate;
-		if (optionValues?.onDelete !== void 0) value.onDelete = optionValues.onDelete;
-		if (optionValues?.match !== void 0) value.match = optionValues.match;
-	}
-	return Object.freeze(value);
-}
-//#endregion
-//#region src/schema/registry.ts
-/** The first naming-policy version used by schema metadata. */
-const schemaNamingPolicyVersion = 1;
-/**
-* The built-in naming policy for schema-generated physical names.
-*
-* Explicit names supplied to `table()` remain unchanged. The policy is used by tooling when it
-* needs a physical name for a logical table ID.
-*/
-const defaultSchemaNamingPolicy = Object.freeze({
-	version: 1,
-	tableName: snakeCaseIdentifier
-});
-/** Error thrown when a root schema fails registry or naming validation. */
-var SchemaValidationError = class extends Error {
-	name = "SchemaValidationError";
-	diagnostics;
-	/** Alias matching validation libraries that call findings "issues". */
-	issues;
-	constructor(diagnostics) {
-		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
-			...diagnostic,
-			path: Object.freeze([...diagnostic.path]),
-			relatedPaths: diagnostic.relatedPaths ? Object.freeze(diagnostic.relatedPaths.map((path) => Object.freeze([...path]))) : void 0
-		})));
-		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
-		this.diagnostics = frozenDiagnostics;
-		this.issues = frozenDiagnostics;
-	}
-};
-function entriesOf(input) {
-	if (Array.isArray(input)) return input;
-	return Object.entries(input);
-}
-function validLogicalId(id) {
-	return id.length > 0 && id === id.trim() && !/[.\\/\u0000-\u001f\u007f]/u.test(id);
-}
-function validNamespace(namespace) {
-	return namespace.length > 0 && namespace === namespace.trim() && !/[.\\/\u0000-\u001f\u007f"']/u.test(namespace);
-}
-function validateEntries(entries, namespace, namingPolicy) {
-	const diagnostics = [];
-	const ids = /* @__PURE__ */ new Map();
-	const physicalNames = /* @__PURE__ */ new Map();
-	const generatedNames = /* @__PURE__ */ new Map();
-	for (const [index, [id, table]] of entries.entries()) {
-		const path = ["tables", id];
-		const previousId = ids.get(id);
-		if (previousId !== void 0) diagnostics.push({
-			code: "duplicate-table-id",
-			message: `Table ID "${id}" is declared more than once`,
-			path,
-			relatedPaths: [["tables", entries[previousId][0]]]
-		});
-		else ids.set(id, index);
-		if (!validLogicalId(id)) diagnostics.push({
-			code: "invalid-table-id",
-			message: `Table ID "${id}" must be a non-empty logical identifier`,
-			path
-		});
-		const physicalName = table.tableName || namingPolicy.tableName(id);
-		const previousPhysicalName = physicalNames.get(physicalName);
-		if (previousPhysicalName !== void 0) diagnostics.push({
-			code: "duplicate-physical-name",
-			message: `Tables "${entries[previousPhysicalName][0]}" and "${id}" both use physical name "${physicalName}"`,
-			path: [...path, "physicalName"],
-			relatedPaths: [[
-				"tables",
-				entries[previousPhysicalName][0],
-				"physicalName"
-			]]
-		});
-		else physicalNames.set(physicalName, index);
-		const generatedName = namingPolicy.tableName(id);
-		const previousGeneratedName = generatedNames.get(generatedName);
-		if (previousGeneratedName !== void 0) diagnostics.push({
-			code: "generated-name-collision",
-			message: `Logical table IDs "${entries[previousGeneratedName][0]}" and "${id}" generate the same physical name "${generatedName}"`,
-			path: [...path, "generatedName"],
-			relatedPaths: [[
-				"tables",
-				entries[previousGeneratedName][0],
-				"generatedName"
-			]]
-		});
-		else generatedNames.set(generatedName, index);
-	}
-	if (namespace !== void 0 && !validNamespace(namespace)) diagnostics.push({
-		code: "invalid-namespace",
-		message: `Schema namespace "${namespace}" must be a non-empty identifier without qualification or control characters`,
-		path: ["namespace"]
-	});
-	return Object.freeze(diagnostics);
-}
-function freezeTableNames(entries, namingPolicy) {
-	return Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, table.tableName || namingPolicy.tableName(id)])));
-}
-function createSchema(entries, tables, options = {}) {
-	const namingPolicy = options.namingPolicy ?? defaultSchemaNamingPolicy;
-	const diagnostics = validateEntries(entries, options.namespace, namingPolicy);
-	if (diagnostics.length > 0) throw new SchemaValidationError(diagnostics);
-	const tableNames = freezeTableNames(entries, namingPolicy);
-	const registry = Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, Object.freeze({
-		id,
-		table,
-		physicalName: tableNames[id]
-	})])));
-	return Object.freeze({
-		schemaKind: "schema",
-		tables: Object.freeze({ ...tables }),
-		registry,
-		tableNames,
-		namespace: options.namespace,
-		namingPolicy: Object.freeze({ ...namingPolicy })
-	});
-}
-function schema(tables, options) {
-	const entries = entriesOf(tables);
-	return createSchema(entries, Object.fromEntries(entries), options);
-}
-/** Generate a v1 physical name for a logical table ID. */
-function generatedTableName(logicalId, namingPolicy = defaultSchemaNamingPolicy) {
-	return namingPolicy.tableName(logicalId);
-}
-//#endregion
-export { index as C, unsafeSchemaSql as S, isUnsafeSchemaSql as _, schemaNamingPolicyVersion as a, renderSchemaSql as b, check as c, references as d, unique as f, defineSchemaExpression as g, SchemaExpressionError as h, schema as i, foreignKey as l, validateConstraintDialect as m, defaultSchemaNamingPolicy as n, catalogCheck as o, uniqueConstraint as p, generatedTableName as r, catalogForeignKey as s, SchemaValidationError as t, primaryKey as u, normalizeSchemaSql as v, validateIndexDialect as w, schemaExpression as x, renderSchemaExpression as y };