qubu 0.0.0 → 0.3.3

package/dist/drizzle-mysql.d.mts

@@ -0,0 +1,24 @@
+import { Pt as AnyTable, Xr as Schema, ni as SchemaTableRecord } from "./types-4Q076HKo.mjs";
+import { r as DrizzleSchemaValidation, t as DrizzleColumnConfig } from "./types-CO1KaRNc.mjs";
+import { MySqlColumn, MySqlTableWithColumns } from "drizzle-orm/mysql-core";
+//#region src/drizzle/mysql.d.ts
+type MysqlDrizzleColumn<TTableName extends string, TDefinition> = MySqlColumn<DrizzleColumnConfig<TTableName, TDefinition, 'MySqlCustomColumn'>>;
+type MysqlDrizzleColumns<TTable extends AnyTable> = { [TKey in keyof TTable['definitions']]: MysqlDrizzleColumn<TTable['tableName'], TTable['definitions'][TKey]>; };
+/** The Drizzle MySQL table produced for one Qubu table. */
+type MysqlDrizzleTable<TTable extends AnyTable> = MySqlTableWithColumns<{
+  name: TTable['tableName'];
+  schema: string | undefined;
+  columns: MysqlDrizzleColumns<TTable>;
+  dialect: 'mysql';
+}>;
+/** A MySQL Drizzle table record retaining Qubu's logical table keys. */
+type MysqlDrizzleSchema<TSchema extends Schema<any>> = { readonly [TKey in keyof TSchema['tables']]: MysqlDrizzleTable<TSchema['tables'][TKey]>; };
+/**
+ * Convert a live Qubu schema registry into MySQL Drizzle table objects.
+ *
+ * @throws A snapshot validation error for invalid MySQL metadata, or a
+ * DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
+ */
+declare function toMysqlDrizzleSchema<const TTables extends SchemaTableRecord>(schema: Schema<TTables> & DrizzleSchemaValidation<TTables, 'mysql'>): MysqlDrizzleSchema<Schema<TTables>>;
+//#endregion
+export { MysqlDrizzleSchema, MysqlDrizzleTable, toMysqlDrizzleSchema };

package/dist/drizzle-mysql.mjs

@@ -0,0 +1,72 @@
+import { t as createMysqlSchemaSnapshot } from "./mysql-DqkqXB6A.mjs";
+import { i as stringExtension, n as extensionData, t as convertDrizzleSchema } from "./runtime-BTr-MTlo.mjs";
+import { bigint, boolean, char, check, customType, date, datetime, decimal, foreignKey, index, int, json, mysqlSchema, mysqlTable, primaryKey, text, unique, uniqueIndex } from "drizzle-orm/mysql-core";
+//#region src/drizzle/mysql.ts
+const mysqlAdapter = {
+	dialect: "mysql",
+	createSnapshot: createMysqlSchemaSnapshot,
+	createTableFactory(namespace) {
+		return namespace === void 0 ? mysqlTable : mysqlSchema(namespace).table;
+	},
+	createStorageBuilder: createMysqlStorageBuilder,
+	applyIdentity(builder, definition) {
+		const extension = definition.identity?.dialect;
+		return extension?.dialect === "mysql" && "autoIncrement" in extension && extension.autoIncrement === true && builder.autoincrement ? builder.autoincrement() : builder;
+	},
+	createPrimaryKey(name, columns) {
+		return primaryKey({
+			name,
+			columns
+		});
+	},
+	createUniqueConstraint(name, columns) {
+		return unique(name).on(...columns);
+	},
+	createCheck: check,
+	createForeignKey(name, columns, foreignColumns) {
+		return foreignKey({
+			name,
+			columns,
+			foreignColumns
+		});
+	},
+	createIndex(indexDefinition, terms) {
+		const data = extensionData(indexDefinition.dialect);
+		let builder = (indexDefinition.unique ? uniqueIndex(indexDefinition.physicalName) : index(indexDefinition.physicalName)).on(...terms);
+		const using = stringExtension(data, "using");
+		const algorithm = stringExtension(data, "algorithm");
+		const lock = stringExtension(data, "lock");
+		if (using) builder = builder.using(using);
+		if (algorithm) builder = builder.algorithm(algorithm);
+		if (lock) builder = builder.lock(lock);
+		return builder;
+	}
+};
+/**
+* Convert a live Qubu schema registry into MySQL Drizzle table objects.
+*
+* @throws A snapshot validation error for invalid MySQL metadata, or a
+* DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
+*/
+function toMysqlDrizzleSchema(schema) {
+	return convertDrizzleSchema(schema, mysqlAdapter);
+}
+function createMysqlStorageBuilder(type, name, declaration) {
+	return (() => {
+		switch (type) {
+			case "integer": return int(name);
+			case "numeric": return decimal(name, { mode: "number" });
+			case "text": return text(name);
+			case "boolean": return boolean(name);
+			case "date": return date(name, { mode: "date" });
+			case "timestamp": return datetime(name, { mode: "date" });
+			case "uuid": return char(name, { length: 36 });
+			case "json": return json(name);
+			case "bigint": return bigint(name, { mode: "bigint" });
+			case "binary": return customType({ dataType: () => declaration })(name);
+			default: return customType({ dataType: () => declaration })(name);
+		}
+	})();
+}
+//#endregion
+export { toMysqlDrizzleSchema };

package/dist/drizzle-postgres.d.mts

@@ -0,0 +1,24 @@
+import { Pt as AnyTable, Xr as Schema, ni as SchemaTableRecord } from "./types-4Q076HKo.mjs";
+import { r as DrizzleSchemaValidation, t as DrizzleColumnConfig } from "./types-CO1KaRNc.mjs";
+import { PgColumn, PgTableWithColumns } from "drizzle-orm/pg-core";
+//#region src/drizzle/postgres.d.ts
+type PostgresDrizzleColumn<TTableName extends string, TDefinition> = PgColumn<DrizzleColumnConfig<TTableName, TDefinition, 'PgCustomColumn'>>;
+type PostgresDrizzleColumns<TTable extends AnyTable> = { [TKey in keyof TTable['definitions']]: PostgresDrizzleColumn<TTable['tableName'], TTable['definitions'][TKey]>; };
+/** The Drizzle PostgreSQL table produced for one Qubu table. */
+type PostgresDrizzleTable<TTable extends AnyTable> = PgTableWithColumns<{
+  name: TTable['tableName'];
+  schema: string | undefined;
+  columns: PostgresDrizzleColumns<TTable>;
+  dialect: 'pg';
+}>;
+/** A PostgreSQL Drizzle table record retaining Qubu's logical table keys. */
+type PostgresDrizzleSchema<TSchema extends Schema<any>> = { readonly [TKey in keyof TSchema['tables']]: PostgresDrizzleTable<TSchema['tables'][TKey]>; };
+/**
+ * Convert a live Qubu schema registry into PostgreSQL Drizzle table objects.
+ *
+ * @throws A snapshot validation error for invalid PostgreSQL metadata, or a
+ * DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
+ */
+declare function toPostgresDrizzleSchema<const TTables extends SchemaTableRecord>(schema: Schema<TTables> & DrizzleSchemaValidation<TTables, 'postgresql'>): PostgresDrizzleSchema<Schema<TTables>>;
+//#endregion
+export { PostgresDrizzleSchema, PostgresDrizzleTable, toPostgresDrizzleSchema };

package/dist/drizzle-postgres.mjs

@@ -0,0 +1,73 @@
+import { t as createPostgresSchemaSnapshot } from "./postgres-DEBBeh52.mjs";
+import { i as stringExtension, n as extensionData, r as recordExtension, t as convertDrizzleSchema } from "./runtime-BTr-MTlo.mjs";
+import { bigint, boolean, check, customType, date, foreignKey, index, integer, jsonb, numeric, pgSchema, pgTable, primaryKey, text, timestamp, unique, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+//#region src/drizzle/postgres.ts
+const postgresAdapter = {
+	dialect: "postgresql",
+	createSnapshot: createPostgresSchemaSnapshot,
+	createTableFactory(namespace) {
+		return namespace === void 0 ? pgTable : pgSchema(namespace).table;
+	},
+	createStorageBuilder: createPostgresStorageBuilder,
+	applyIdentity(builder, _definition, column) {
+		const method = column.identity?.generation === "always" ? builder.generatedAlwaysAsIdentity : builder.generatedByDefaultAsIdentity;
+		return method === void 0 ? builder : method.call(builder);
+	},
+	createPrimaryKey(name, columns) {
+		return primaryKey({
+			name,
+			columns
+		});
+	},
+	createUniqueConstraint(name, columns, nullsNotDistinct) {
+		const builder = unique(name).on(...columns);
+		return nullsNotDistinct ? builder.nullsNotDistinct() : builder;
+	},
+	createCheck: check,
+	createForeignKey(name, columns, foreignColumns) {
+		return foreignKey({
+			name,
+			columns,
+			foreignColumns
+		});
+	},
+	createIndex(indexDefinition, terms, predicate) {
+		const data = extensionData(indexDefinition.dialect);
+		const start = indexDefinition.unique ? uniqueIndex(indexDefinition.physicalName) : index(indexDefinition.physicalName);
+		const method = stringExtension(data, "method");
+		let builder = method ? start.using(method, ...terms) : start.on(...terms);
+		if (data.concurrently === true) builder = builder.concurrently();
+		const storageParameters = recordExtension(data, "storageParameters");
+		if (storageParameters) builder = builder.with(storageParameters);
+		if (predicate) builder = builder.where(predicate);
+		return builder;
+	}
+};
+/**
+* Convert a live Qubu schema registry into PostgreSQL Drizzle table objects.
+*
+* @throws A snapshot validation error for invalid PostgreSQL metadata, or a
+* DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
+*/
+function toPostgresDrizzleSchema(schema) {
+	return convertDrizzleSchema(schema, postgresAdapter);
+}
+function createPostgresStorageBuilder(type, name, declaration) {
+	return (() => {
+		switch (type) {
+			case "integer": return integer(name);
+			case "numeric": return numeric(name, { mode: "number" });
+			case "text": return text(name);
+			case "boolean": return boolean(name);
+			case "date": return date(name, { mode: "date" });
+			case "timestamp": return timestamp(name, { mode: "date" });
+			case "uuid": return uuid(name);
+			case "json": return jsonb(name);
+			case "bigint": return bigint(name, { mode: "bigint" });
+			case "binary": return customType({ dataType: () => declaration })(name);
+			default: return customType({ dataType: () => declaration })(name);
+		}
+	})();
+}
+//#endregion
+export { toPostgresDrizzleSchema };

package/dist/drizzle-sqlite.d.mts

@@ -0,0 +1,24 @@
+import { Pt as AnyTable, Xr as Schema, ni as SchemaTableRecord } from "./types-4Q076HKo.mjs";
+import { r as DrizzleSchemaValidation, t as DrizzleColumnConfig } from "./types-CO1KaRNc.mjs";
+import { SQLiteColumn, SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
+//#region src/drizzle/sqlite.d.ts
+type SqliteDrizzleColumn<TTableName extends string, TDefinition> = SQLiteColumn<DrizzleColumnConfig<TTableName, TDefinition, 'SQLiteCustomColumn'>>;
+type SqliteDrizzleColumns<TTable extends AnyTable> = { [TKey in keyof TTable['definitions']]: SqliteDrizzleColumn<TTable['tableName'], TTable['definitions'][TKey]>; };
+/** The Drizzle SQLite table produced for one Qubu table. */
+type SqliteDrizzleTable<TTable extends AnyTable> = SQLiteTableWithColumns<{
+  name: TTable['tableName'];
+  schema: undefined;
+  columns: SqliteDrizzleColumns<TTable>;
+  dialect: 'sqlite';
+}>;
+/** A SQLite Drizzle table record retaining Qubu's logical table keys. */
+type SqliteDrizzleSchema<TSchema extends Schema<any>> = { readonly [TKey in keyof TSchema['tables']]: SqliteDrizzleTable<TSchema['tables'][TKey]>; };
+/**
+ * Convert a live Qubu schema registry into SQLite Drizzle table objects.
+ *
+ * @throws A snapshot validation error for invalid SQLite metadata, or a
+ * DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
+ */
+declare function toSqliteDrizzleSchema<const TTables extends SchemaTableRecord>(schema: Schema<TTables> & DrizzleSchemaValidation<TTables, 'sqlite'>): SqliteDrizzleSchema<Schema<TTables>>;
+//#endregion
+export { SqliteDrizzleSchema, SqliteDrizzleTable, toSqliteDrizzleSchema };

package/dist/drizzle-sqlite.mjs

@@ -0,0 +1,82 @@
+import { t as createSqliteSchemaSnapshot } from "./sqlite-BU6DBxef.mjs";
+import { t as convertDrizzleSchema } from "./runtime-BTr-MTlo.mjs";
+import { blob, check, customType, foreignKey, index, integer, primaryKey, sqliteTable, text, unique, uniqueIndex } from "drizzle-orm/sqlite-core";
+//#region src/drizzle/sqlite.ts
+const sqliteAdapter = {
+	dialect: "sqlite",
+	createSnapshot: createSqliteSchemaSnapshot,
+	createTableFactory() {
+		return sqliteTable;
+	},
+	createStorageBuilder: createSqliteStorageBuilder,
+	applyIdentity(builder, definition, column, table) {
+		const extension = definition.identity?.dialect;
+		const autoIncrement = extension?.dialect === "sqlite" && "autoIncrement" in extension && extension.autoIncrement === true;
+		const isSingleColumnPrimaryKey = table.constraints.some((constraint) => constraint.kind === "primary-key" && constraint.columns.length === 1 && constraint.columns[0] === column.id);
+		return autoIncrement && isSingleColumnPrimaryKey && builder.primaryKey ? builder.primaryKey({ autoIncrement: true }) : builder;
+	},
+	createPrimaryKey(name, columns) {
+		return primaryKey({
+			name,
+			columns
+		});
+	},
+	createUniqueConstraint(name, columns) {
+		return unique(name).on(...columns);
+	},
+	createCheck: check,
+	createForeignKey(name, columns, foreignColumns) {
+		return foreignKey({
+			name,
+			columns,
+			foreignColumns
+		});
+	},
+	createIndex(indexDefinition, terms, predicate) {
+		let builder = (indexDefinition.unique ? uniqueIndex(indexDefinition.physicalName) : index(indexDefinition.physicalName)).on(...terms);
+		if (predicate) builder = builder.where(predicate);
+		return builder;
+	}
+};
+/**
+* Convert a live Qubu schema registry into SQLite Drizzle table objects.
+*
+* @throws A snapshot validation error for invalid SQLite metadata, or a
+* DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
+*/
+function toSqliteDrizzleSchema(schema) {
+	return convertDrizzleSchema(schema, sqliteAdapter);
+}
+function createSqliteStorageBuilder(type, name, declaration) {
+	return (() => {
+		switch (type) {
+			case "integer": return integer(name);
+			case "numeric": return customType({
+				dataType: () => declaration,
+				fromDriver: (value) => Number(value)
+			})(name);
+			case "text": return text(name);
+			case "boolean": return integer(name, { mode: "boolean" });
+			case "date": return customType({
+				dataType: () => declaration,
+				fromDriver: (value) => new Date(value),
+				toDriver: (value) => value.toISOString().slice(0, 10)
+			})(name);
+			case "timestamp": return customType({
+				dataType: () => declaration,
+				fromDriver: (value) => new Date(value),
+				toDriver: (value) => value.toISOString()
+			})(name);
+			case "uuid": return text(name);
+			case "json": return text(name, { mode: "json" });
+			case "bigint": return customType({
+				dataType: () => declaration,
+				fromDriver: (value) => BigInt(value)
+			})(name);
+			case "binary": return blob(name, { mode: "buffer" });
+			default: return customType({ dataType: () => declaration })(name);
+		}
+	})();
+}
+//#endregion
+export { toSqliteDrizzleSchema };

package/dist/drizzle.d.mts

@@ -0,0 +1,13 @@
+import { n as DrizzleDialect } from "./types-CO1KaRNc.mjs";
+//#region src/drizzle/errors.d.ts
+/** Stable failure categories raised while building a Drizzle schema. */
+type DrizzleSchemaConversionErrorCode = 'missing-storage' | 'unsupported-metadata';
+/** A path-addressed failure raised when Drizzle cannot represent Qubu metadata. */
+declare class DrizzleSchemaConversionError extends TypeError {
+  readonly name = "DrizzleSchemaConversionError";
+  readonly code: DrizzleSchemaConversionErrorCode;
+  readonly path: readonly (string | number)[];
+  constructor(code: DrizzleSchemaConversionErrorCode, message: string, path: readonly (string | number)[]);
+}
+//#endregion
+export { type DrizzleDialect, DrizzleSchemaConversionError, type DrizzleSchemaConversionErrorCode };

package/dist/drizzle.mjs

@@ -0,0 +1,2 @@
+import { t as DrizzleSchemaConversionError } from "./errors-BGCoLe_r.mjs";
+export { DrizzleSchemaConversionError };

package/dist/errors-BGCoLe_r.mjs

@@ -0,0 +1,14 @@
+//#region src/drizzle/errors.ts
+/** A path-addressed failure raised when Drizzle cannot represent Qubu metadata. */
+var DrizzleSchemaConversionError = class extends TypeError {
+	name = "DrizzleSchemaConversionError";
+	code;
+	path;
+	constructor(code, message, path) {
+		super(message);
+		this.code = code;
+		this.path = Object.freeze([...path]);
+	}
+};
+//#endregion
+export { DrizzleSchemaConversionError as t };

package/dist/errors-Dxv73YJu.mjs

@@ -0,0 +1,26 @@
+//#region src/query/errors.ts
+/** Raised when a query cannot satisfy Qubu's runtime authoring rules. */
+var QueryValidationError = class extends TypeError {
+	name = "QueryValidationError";
+	code;
+	context;
+	path;
+	hint;
+	issue;
+	constructor(issue) {
+		super(issue.message);
+		this.code = issue.code;
+		this.context = issue.context;
+		this.path = Object.freeze([...issue.path]);
+		this.hint = issue.hint;
+		this.issue = Object.freeze({
+			...issue,
+			path: this.path
+		});
+	}
+};
+function queryValidationError(issue) {
+	return new QueryValidationError(issue);
+}
+//#endregion
+export { queryValidationError as n, QueryValidationError as t };

package/dist/explain-CkIK13L_.mjs

@@ -0,0 +1,98 @@
+import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
+//#region src/dialects/explain.ts
+const readQueryKinds = /* @__PURE__ */ new Set(["select", "set"]);
+function assertExplainAnalysisAllowed(dialect, queryKind, options) {
+	if (options.analyze !== true || readQueryKinds.has(queryKind)) return;
+	throwExplainError("invalid-explain-query", dialect, ["analyze"], `EXPLAIN ANALYZE is only available for read queries; received ${queryKind}`, "Remove analyze for a plan-only mutation EXPLAIN.");
+}
+function assertSupportedExplainOptions(dialect, options, supported) {
+	for (const option of explainOptionNames) {
+		if (options[option] === void 0 || supported.includes(option)) continue;
+		throwExplainError("unsupported-explain-option", dialect, [option], `The ${dialect} EXPLAIN policy does not support the "${option}" option`, `Remove ${option} or use a dialect that supports it.`);
+	}
+}
+function assertBooleanExplainOption(dialect, option, value) {
+	if (value === void 0 || typeof value === "boolean") return;
+	throwExplainError("invalid-explain-options", dialect, [option], `The ${dialect} EXPLAIN option "${option}" must be boolean`, `Set ${option} to true or false.`);
+}
+function unsupportedExplainFormat(dialect, format, supported) {
+	throwExplainError("unsupported-explain-option", dialect, ["format"], `The ${dialect} EXPLAIN policy does not support the "${String(format)}" format`, `Use one of: ${supported.join(", ")}.`);
+}
+function invalidExplainCombination(dialect, path, message, hint) {
+	throwExplainError("invalid-explain-options", dialect, path, message, hint);
+}
+const postgresExplain = { render(statement, queryKind, options) {
+	assertExplainAnalysisAllowed("PostgreSQL", queryKind, options);
+	assertSupportedExplainOptions("PostgreSQL", options, [
+		"analyze",
+		"verbose",
+		"buffers",
+		"format"
+	]);
+	assertBooleanExplainOption("PostgreSQL", "analyze", options.analyze);
+	assertBooleanExplainOption("PostgreSQL", "verbose", options.verbose);
+	assertBooleanExplainOption("PostgreSQL", "buffers", options.buffers);
+	const format = options.format;
+	if (format !== void 0 && !postgresExplainFormats.includes(format)) unsupportedExplainFormat("PostgreSQL", format, postgresExplainFormats);
+	if (options.buffers === true && options.analyze !== true) invalidExplainCombination("PostgreSQL", ["buffers"], "PostgreSQL EXPLAIN BUFFERS requires ANALYZE", "Set analyze: true for a read query, or remove buffers.");
+	const clauses = [
+		options.analyze === true ? "ANALYZE" : void 0,
+		options.verbose === true ? "VERBOSE" : void 0,
+		options.buffers === true ? "BUFFERS" : void 0,
+		format === void 0 ? void 0 : `FORMAT ${String(format).toUpperCase()}`
+	].filter((value) => value !== void 0);
+	return `EXPLAIN${clauses.length === 0 ? "" : ` (${clauses.join(", ")})`} ${statement}`;
+} };
+const sqliteExplain = { render(statement, queryKind, options) {
+	assertExplainAnalysisAllowed("SQLite", queryKind, options);
+	assertSupportedExplainOptions("SQLite", options, ["format", "queryPlan"]);
+	assertBooleanExplainOption("SQLite", "queryPlan", options.queryPlan);
+	const format = options.format;
+	if (format !== void 0 && !sqliteExplainFormats.includes(format)) unsupportedExplainFormat("SQLite", format, sqliteExplainFormats);
+	const formatIsQueryPlan = format === "query-plan";
+	const formatIsBytecode = format === "bytecode";
+	if (formatIsQueryPlan && options.queryPlan === false) invalidExplainCombination("SQLite", ["format", "queryPlan"], "SQLite EXPLAIN format \"query-plan\" conflicts with queryPlan: false", "Choose query-plan or bytecode mode, not both.");
+	if (formatIsBytecode && options.queryPlan === true) invalidExplainCombination("SQLite", ["format", "queryPlan"], "SQLite EXPLAIN format \"bytecode\" conflicts with queryPlan: true", "Choose query-plan or bytecode mode, not both.");
+	return `${formatIsQueryPlan || !formatIsBytecode && options.queryPlan !== false ? "EXPLAIN QUERY PLAN" : "EXPLAIN"} ${statement}`;
+} };
+const mysqlExplain = { render(statement, queryKind, options) {
+	assertExplainAnalysisAllowed("MySQL", queryKind, options);
+	assertSupportedExplainOptions("MySQL", options, ["analyze", "format"]);
+	assertBooleanExplainOption("MySQL", "analyze", options.analyze);
+	const format = options.format;
+	if (format !== void 0 && !mysqlExplainFormats.includes(format)) unsupportedExplainFormat("MySQL", format, mysqlExplainFormats);
+	if (options.analyze === true && format !== void 0) invalidExplainCombination("MySQL", ["analyze", "format"], "MySQL EXPLAIN ANALYZE cannot be combined with FORMAT", "Use analyze for the tree analyzer output, or choose a FORMAT without analyze.");
+	if (options.analyze === true) return `EXPLAIN ANALYZE ${statement}`;
+	if (format === void 0) return `EXPLAIN ${statement}`;
+	return `EXPLAIN FORMAT=${String(format).toUpperCase()} ${statement}`;
+} };
+const explainOptionNames = [
+	"analyze",
+	"verbose",
+	"buffers",
+	"format",
+	"queryPlan"
+];
+const postgresExplainFormats = [
+	"text",
+	"xml",
+	"json",
+	"yaml"
+];
+const sqliteExplainFormats = ["query-plan", "bytecode"];
+const mysqlExplainFormats = [
+	"traditional",
+	"json",
+	"tree"
+];
+function throwExplainError(code, dialect, path, message, hint) {
+	throw queryValidationError({
+		code,
+		context: `dialect.${dialect.toLowerCase()}.explain`,
+		path,
+		message,
+		hint
+	});
+}
+//#endregion
+export { postgresExplain as n, sqliteExplain as r, mysqlExplain as t };

package/dist/index-Ds7-mhJi.d.mts

@@ -0,0 +1,146 @@
+import { Mr as SchemaDialect, T as SnapshotJsonValue, Xr 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-4Q076HKo.mjs";
+import { n as CompleteSchemaSnapshotInput, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult } from "./complete-types-BdFqUfbb.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 digest for cache keys and diagnostics.
+ * It is deliberately not an entity identity, signature, or migration lineage.
+ */
+declare function schemaSnapshotDigest(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 digest for a complete Snapshot v2. */
+declare function completeSchemaSnapshotDigest(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 schemaSnapshotV2Digest: typeof completeSchemaSnapshotDigest;
+declare const decodeCompleteSnapshot: typeof decodeCompleteSchemaSnapshot;
+declare const assertCompleteSnapshot: typeof assertCompleteSchemaSnapshot;
+declare const encodeCompleteSnapshot: typeof encodeCompleteSchemaSnapshot;
+declare const digestCompleteSchemaSnapshot: typeof completeSchemaSnapshotDigest;
+//#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 digest helper. */
+declare const digestSchemaSnapshot: typeof schemaSnapshotDigest;
+//#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, encodeSnapshot as E, assertCompleteSnapshot as F, encodeCompleteSnapshot as G, decodeSchemaSnapshotV2 as H, assertSchemaSnapshotV2 as I, SnapshotCanonicalError as J, encodeSchemaSnapshotV2 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, encodeSchemaSnapshot as T, digestCompleteSchemaSnapshot as U, decodeCompleteSnapshot as V, encodeCompleteSchemaSnapshot as W, encodeCanonicalSnapshot as X, canonicalJson as Y, schemaSnapshotDigest 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, schemaSnapshotV2Digest as q, mysqlSchemaDialect as r, SqliteSnapshotOptions as s, MysqlSnapshotOptions as t, sqliteSchemaDialect as u, postgresSnapshotAdapter as v, digestSchemaSnapshot as w, SchemaSnapshotOptions as x, postgresSnapshotDialect as y, completeSchemaSnapshotDigest as z };