qubu 0.0.0 → 0.3.3

package/dist/codegen.mjs

@@ -0,0 +1,1199 @@
+import { l as decodeSchemaSnapshot } from "./canonical-BbnqavJm.mjs";
+import { t as mapCatalogToSnapshot } from "./snapshot-CWPgzxNx.mjs";
+//#region src/codegen/source.ts
+const header = `/* Generated by Qubu. Do not edit this machine-owned file. */
+import * as _qubu from 'qubu'
+`;
+const catalogColumnHelper = `type _CatalogColumnOptions = Omit<_qubu.ColumnOptions, 'storage'> & {
+  readonly storage?: never
+}
+
+const _catalogColumn = <
+  TOutput = unknown,
+  TInsert = unknown,
+  TUpdate = unknown,
+  TSqlType extends _qubu.AnySqlType = _qubu.SqlUnknown,
+>() =>
+  <
+    const TDialect extends string,
+    const TDeclaration extends string,
+    const TOptions extends _CatalogColumnOptions,
+  >(
+    dialect: TDialect,
+    declaration: TDeclaration,
+    options: TOptions
+  ) =>
+    _qubu.nativeColumn<
+      TOutput,
+      TInsert,
+      TUpdate,
+      TOptions,
+      TSqlType,
+      TDialect,
+      TDeclaration
+    >(_qubu.nativeStorage(dialect, declaration), options)
+`;
+const catalogPredicateHelper = `const _catalogPredicate = <
+  const TDialect extends _qubu.SchemaDialectName,
+>(input: _qubu.CatalogCheckSql<TDialect>) =>
+  _qubu.catalogCheck(input).expression
+`;
+function printSchemaSource(schema, diagnostics) {
+	const tables = schema.tables.map((table) => printTable(schema, table, diagnostics));
+	if (tables.some((table) => table === void 0)) return void 0;
+	const registry = schema.tables.map((table) => `    ${literal(table.name)}: ${table.name},`).join("\n");
+	const predicateHelper = schema.tables.some((table) => table.indexes.some((index) => index.snapshot.predicate !== void 0)) ? `\n${catalogPredicateHelper}` : "";
+	const columnHelper = schema.tables.some((table) => table.columns.length > 0) ? `\n${catalogColumnHelper}` : "";
+	return `${header}${columnHelper}${predicateHelper}\n${tables.join("\n\n")}\n\nexport const ${schema.name} = _qubu.schema(\n  {\n${registry}\n  },\n  { namespace: ${literal(schema.namespace)} }\n)\n`;
+}
+function printTable(schema, table, diagnostics) {
+	const columns = table.columns.map((column) => printColumn(schema, table, column, diagnostics));
+	const constraints = table.constraints.map((constraint) => printConstraint(schema, table, constraint, diagnostics));
+	const indexes = table.indexes.map((index) => printIndex(schema, table, index, diagnostics));
+	if (columns.some((value) => value === void 0) || constraints.some((value) => value === void 0) || indexes.some((value) => value === void 0)) return;
+	const typePrefix = `_${capitalize(table.name)}`;
+	const definitionsName = `${typePrefix}Definitions`;
+	const columnsName = `${typePrefix}Columns`;
+	const constraintsName = `${typePrefix}Constraints`;
+	const indexesName = `${typePrefix}Indexes`;
+	const tableTypeName = `${typePrefix}Table`;
+	const constraintTypes = table.constraints.map((constraint) => printConstraintType(table, constraint, columnsName, diagnostics));
+	const indexTypes = table.indexes.map((index) => printIndexType(table, index, columnsName, diagnostics));
+	if (constraintTypes.some((value) => value === void 0) || indexTypes.some((value) => value === void 0)) return;
+	return `const ${definitionsName} = {
+${columns.map((value) => indent(value ?? "", 2)).join("\n")}
+}
+
+type ${columnsName} = _qubu.TableColumns<
+  typeof ${definitionsName},
+  _qubu.TableIdentity<${literal(table.snapshot.physicalName)}>
+>
+
+type ${constraintsName} = {
+${constraintTypes.map((value) => indent(value ?? "", 2)).join("\n")}
+}
+
+type ${indexesName} = {
+${indexTypes.map((value) => indent(value ?? "", 2)).join("\n")}
+}
+
+type ${tableTypeName} = _qubu.Table<
+  ${literal(table.snapshot.physicalName)},
+  typeof ${definitionsName},
+  ${constraintsName},
+  ${indexesName}
+> & {
+  readonly columns: ${columnsName}
+}
+
+export const ${table.name}: ${tableTypeName} = _qubu.table(
+  ${literal(table.snapshot.physicalName)},
+  ${definitionsName},
+  _current => ({
+    constraints: {
+${constraints.map((value) => indent(value ?? "", 6)).join("\n")}
+    },
+    indexes: {
+${indexes.map((value) => indent(value ?? "", 6)).join("\n")}
+    },
+  })
+)`;
+}
+function printConstraintType(table, constraint, columnsName, diagnostics) {
+	const snapshot = constraint.snapshot;
+	const path = [
+		"snapshot",
+		"tables",
+		table.snapshot.id,
+		"constraints",
+		snapshot.id
+	];
+	if (snapshot.kind === "check") return `readonly ${literal(constraint.name)}: _qubu.CheckConstraint`;
+	const columns = printColumnTypeTuple(table, snapshot.columns, columnsName, path, diagnostics);
+	if (columns === void 0) return void 0;
+	if (snapshot.kind === "foreign-key") return `readonly ${literal(constraint.name)}: _qubu.ForeignKeyConstraint<${columns}>`;
+	if (snapshot.kind === "unique-constraint") return `readonly ${literal(constraint.name)}: _qubu.UniqueConstraint<
+  ${columns},
+  ${literal(snapshot.nulls)}
+>`;
+	return `readonly ${literal(constraint.name)}: _qubu.KeyConstraint<
+  ${literal(snapshot.kind)},
+  ${columns}
+>`;
+}
+function printIndexType(table, index, columnsName, diagnostics) {
+	const path = [
+		"snapshot",
+		"tables",
+		table.snapshot.id,
+		"indexes",
+		index.snapshot.id
+	];
+	const terms = index.snapshot.terms.map((term, position) => printIndexTermType(table, term, columnsName, [
+		...path,
+		"terms",
+		position
+	], diagnostics));
+	if (terms.some((term) => term === void 0)) return void 0;
+	const properties = [
+		`readonly terms: readonly [${terms.join(", ")}]`,
+		`readonly unique: ${index.snapshot.unique ? "true" : "false"}`,
+		`readonly candidateKey: ${index.snapshot.candidateKey ? "true" : "false"}`,
+		`readonly predicate: ${index.snapshot.predicate === void 0 ? "undefined" : "_qubu.CatalogCheckExpression"}`
+	];
+	if (index.snapshot.includedColumns !== void 0) {
+		const included = printColumnTypeTuple(table, index.snapshot.includedColumns, columnsName, [...path, "includedColumns"], diagnostics);
+		if (included === void 0) return void 0;
+		properties.push(`readonly includedColumns?: ${included}`);
+	} else properties.push("readonly includedColumns?: undefined");
+	return `readonly ${literal(index.name)}: {
+  readonly kind: 'index'
+${properties.map((property) => `  ${property}`).join("\n")}
+}`;
+}
+function printIndexTermType(table, term, columnsName, path, diagnostics) {
+	if (term.kind !== "order") return printIndexTermExpressionType(table, term, columnsName, path, diagnostics);
+	const expression = printIndexTermExpressionType(table, term.expression, columnsName, [...path, "expression"], diagnostics);
+	return expression === void 0 ? void 0 : `_qubu.OrderTerm<unknown, ${expression}>`;
+}
+function printIndexTermExpressionType(table, expression, columnsName, path, diagnostics) {
+	if (expression.kind === "expression") return "_qubu.AnyExpression";
+	const column = table.columnsBySnapshotId.get(expression.column);
+	if (column === void 0) {
+		diagnostics.push(sourceError(`Index column "${expression.column}" was not resolved`, [...path, "column"]));
+		return;
+	}
+	return `${columnsName}[${literal(column.name)}]`;
+}
+function printColumnTypeTuple(table, ids, columnsName, path, diagnostics) {
+	const columns = [];
+	for (const [position, id] of ids.entries()) {
+		const column = table.columnsBySnapshotId.get(id);
+		if (column === void 0) {
+			diagnostics.push(sourceError(`Column "${id}" was not resolved`, [
+				...path,
+				"columns",
+				position
+			]));
+			continue;
+		}
+		columns.push(`${columnsName}[${literal(column.name)}]`);
+	}
+	return columns.length === ids.length && columns.length > 0 ? `readonly [${columns.join(", ")}]` : void 0;
+}
+function printColumn(schema, table, column, diagnostics) {
+	const path = [
+		"snapshot",
+		"tables",
+		table.snapshot.id,
+		"columns",
+		column.snapshot.id
+	];
+	const snapshot = column.snapshot;
+	if (snapshot.storage?.kind !== "native") {
+		diagnostics.push(sourceError("Generated columns require native storage", [...path, "storage"]));
+		return;
+	}
+	const options = [`nullable: ${snapshot.nullable ? "true" : "false"}`, `sqlName: ${literal(snapshot.physicalName)}`];
+	if (snapshot.default !== void 0) {
+		if (snapshot.default.kind === "external") options.push("default: _qubu.externalDefault()");
+		else if (snapshot.default.kind === "literal") {
+			const value = printSnapshotLiteral(snapshot.default.value, path, diagnostics);
+			if (value === void 0) return void 0;
+			options.push(`default: ${value}`);
+		} else {
+			const value = printExpression(snapshot.default.expression, schema, [
+				...path,
+				"default",
+				"expression"
+			], diagnostics);
+			if (value === void 0) return void 0;
+			options.push(`default: ${value}`);
+		}
+	}
+	if (snapshot.generatedColumn !== void 0) {
+		if (snapshot.generatedColumn.kind === "external") options.push("generatedColumn: _qubu.externalGeneratedColumn()");
+		else {
+			const expression = printExpression(snapshot.generatedColumn.expression, schema, [
+				...path,
+				"generatedColumn",
+				"expression"
+			], diagnostics);
+			if (expression === void 0) return void 0;
+			options.push(`generatedColumn: _qubu.generatedColumn(${expression}, ${literal(snapshot.generatedColumn.mode)})`);
+		}
+	}
+	if (snapshot.identity !== void 0) {
+		const extension = snapshot.identity.dialect ? printExtension(snapshot.identity.dialect, schema, [
+			...path,
+			"identity",
+			"dialect"
+		], diagnostics) : void 0;
+		if (snapshot.identity.dialect !== void 0 && extension === void 0) return;
+		options.push(extension === void 0 ? `identity: _qubu.identityColumn(${literal(snapshot.identity.generation)})` : `identity: _qubu.identityColumn(${literal(snapshot.identity.generation)}, { dialect: ${extension} })`);
+	}
+	if (snapshot.onUpdate !== void 0) {
+		const expression = printExpression(snapshot.onUpdate, schema, [...path, "onUpdate"], diagnostics);
+		if (expression === void 0) return void 0;
+		options.push(`onUpdate: ${expression}`);
+	}
+	const types = [
+		applicationType(column.output),
+		applicationType(column.insert),
+		applicationType(column.update),
+		sqlDomainType(column.sqlDomain)
+	].join(", ");
+	const optionSource = `{
+${options.map((option) => `  ${option},`).join("\n")}
+}`;
+	return `${literal(column.name)}: _catalogColumn<${types}>()(
+  ${literal(snapshot.storage.dialect)},
+  ${literal(snapshot.storage.type)},
+${indent(optionSource, 2)}
+),`;
+}
+function printConstraint(schema, table, constraint, diagnostics) {
+	const snapshot = constraint.snapshot;
+	const path = [
+		"snapshot",
+		"tables",
+		table.snapshot.id,
+		"constraints",
+		snapshot.id
+	];
+	const options = printConstraintOptions(snapshot, schema, path, diagnostics);
+	if (options === void 0) return void 0;
+	let expression;
+	if (snapshot.kind === "check") {
+		const sql = catalogExpressionData(snapshot.expression, schema, [...path, "expression"], diagnostics);
+		if (sql === void 0) return void 0;
+		expression = `_qubu.catalogCheck(${sql}, ${options})`;
+	} else if (snapshot.kind === "foreign-key") {
+		const local = printColumns(table, snapshot.columns, path, diagnostics);
+		const targetTable = schema.tablesBySnapshotId.get(snapshot.target.table);
+		if (targetTable === void 0) {
+			diagnostics.push(sourceError(`Foreign-key target table "${snapshot.target.table}" was not resolved`, [
+				...path,
+				"target",
+				"table"
+			]));
+			return;
+		}
+		const target = printColumns(targetTable, snapshot.target.columns, [...path, "target"], diagnostics, targetTable.name);
+		if (local === void 0 || target === void 0) return void 0;
+		expression = `_qubu.catalogForeignKey(
+  [${local.join(", ")}],
+  () => _qubu.references(${targetTable.name}, ${target.join(", ")}),
+  ${options}
+)`;
+	} else {
+		const columns = printColumns(table, snapshot.columns, path, diagnostics);
+		if (columns === void 0) return void 0;
+		expression = `_qubu.${snapshot.kind === "primary-key" ? "primaryKey" : snapshot.kind === "unique" ? "unique" : "uniqueConstraint"}(${columns.join(", ")}, ${options})`;
+	}
+	return `${literal(constraint.name)}: ${expression},`;
+}
+function printConstraintOptions(constraint, schema, path, diagnostics) {
+	const properties = [`physicalName: ${literal(constraint.physicalName)}`];
+	if (constraint.kind === "unique-constraint") properties.push(`nulls: ${literal(constraint.nulls)}`);
+	if (constraint.kind === "foreign-key") {
+		if (constraint.onUpdate !== void 0) properties.push(`onUpdate: ${literal(constraint.onUpdate)}`);
+		if (constraint.onDelete !== void 0) properties.push(`onDelete: ${literal(constraint.onDelete)}`);
+		if (constraint.match !== void 0) properties.push(`match: ${literal(constraint.match)}`);
+	}
+	if (constraint.deferrable !== void 0) properties.push(`deferrable: ${constraint.deferrable ? "true" : "false"}`);
+	if (constraint.initially !== void 0) properties.push(`initially: ${literal(constraint.initially)}`);
+	if (constraint.dialect !== void 0) {
+		const extension = printExtension(constraint.dialect, schema, [...path, "dialect"], diagnostics);
+		if (extension === void 0) return void 0;
+		properties.push(`dialect: ${extension}`);
+	}
+	return `{ ${properties.join(", ")} }`;
+}
+function printIndex(schema, table, index, diagnostics) {
+	const path = [
+		"snapshot",
+		"tables",
+		table.snapshot.id,
+		"indexes",
+		index.snapshot.id
+	];
+	const terms = index.snapshot.terms.map((term, termIndex) => printIndexTerm(schema, table, term, [
+		...path,
+		"terms",
+		termIndex
+	], diagnostics));
+	if (terms.some((term) => term === void 0)) return void 0;
+	const options = [`physicalName: ${literal(index.snapshot.physicalName)}`, `unique: ${index.snapshot.unique ? "true" : "false"}`];
+	if (index.snapshot.predicate !== void 0) {
+		const predicate = catalogExpressionData(index.snapshot.predicate, schema, [...path, "predicate"], diagnostics);
+		if (predicate === void 0) return void 0;
+		options.push(`where: _catalogPredicate(${predicate})`);
+	}
+	if (index.snapshot.includedColumns !== void 0) {
+		const included = printColumns(table, index.snapshot.includedColumns, [...path, "includedColumns"], diagnostics);
+		if (included === void 0) return void 0;
+		options.push(`include: [${included.join(", ")}]`);
+	}
+	if (index.snapshot.dialect !== void 0) {
+		const extension = printExtension(index.snapshot.dialect, schema, [...path, "dialect"], diagnostics);
+		if (extension === void 0) return void 0;
+		options.push(`dialect: ${extension}`);
+	}
+	return `${literal(index.name)}: _qubu.index(
+  [${terms.join(", ")}],
+  { ${options.join(", ")} }
+),`;
+}
+function printIndexTerm(schema, table, term, path, diagnostics) {
+	if (term.kind !== "order") return printIndexTermExpression(schema, table, term, path, diagnostics);
+	const expression = printIndexTermExpression(schema, table, term.expression, [...path, "expression"], diagnostics);
+	if (expression === void 0) return void 0;
+	return `_qubu.order(${expression}, ${term.direction === void 0 ? "undefined" : literal(term.direction)}, ${term.nulls === void 0 ? "undefined" : literal(term.nulls)})`;
+}
+function printIndexTermExpression(schema, table, expression, path, diagnostics) {
+	if (expression.kind === "expression") return printExpression(expression.expression, schema, [...path, "expression"], diagnostics);
+	const column = table.columnsBySnapshotId.get(expression.column);
+	if (column === void 0) {
+		diagnostics.push(sourceError(`Index column "${expression.column}" was not resolved`, [...path, "column"]));
+		return;
+	}
+	return `_current.columns[${literal(column.name)}]`;
+}
+function printColumns(table, ids, path, diagnostics, binding = "_current") {
+	const result = [];
+	for (const [index, id] of ids.entries()) {
+		const column = table.columnsBySnapshotId.get(id);
+		if (column === void 0) {
+			diagnostics.push(sourceError(`Column "${id}" was not resolved`, [
+				...path,
+				"columns",
+				index
+			]));
+			continue;
+		}
+		result.push(`${binding}.columns[${literal(column.name)}]`);
+	}
+	return result.length === ids.length && result.length > 0 ? result : void 0;
+}
+function printExpression(expression, schema, path, diagnostics) {
+	const data = catalogExpressionData(expression, schema, path, diagnostics);
+	return data === void 0 ? void 0 : `_qubu.unsafeSchemaSql(${data})`;
+}
+function catalogExpressionData(expression, schema, path, diagnostics) {
+	if (expression.expressionKind !== "unsafe" || expression.dialect !== schema.dialect || expression.sql.trim().length === 0) {
+		diagnostics.push(sourceError("Catalog expressions must be non-empty, unsafe, and tagged for the selected dialect", path));
+		return;
+	}
+	return `{ dialect: ${literal(expression.dialect)}, sql: ${literal(expression.sql)} }`;
+}
+function printExtension(extension, schema, path, diagnostics) {
+	if (extension.dialect !== schema.dialect || extension.version !== 1 || !isJsonObject(extension.data) || Object.hasOwn(extension.data, "dialect")) {
+		diagnostics.push(sourceError("Dialect extensions must be v1 object data for the selected dialect and cannot contain a data field named \"dialect\"", path));
+		return;
+	}
+	const data = extension.data;
+	const entries = Object.keys(data).sort().map((key) => `[${literal(key)}]: ${printJsonValue(data[key])}`);
+	return `{ dialect: ${literal(extension.dialect)}${entries.length === 0 ? "" : `, ${entries.join(", ")}`} }`;
+}
+function printSnapshotLiteral(value, path, diagnostics) {
+	switch (value.kind) {
+		case "null": return "null";
+		case "boolean": return value.value ? "true" : "false";
+		case "string": return literal(value.value);
+		case "bigint": return `BigInt(${literal(value.value)})`;
+		case "number": {
+			const number = Number(value.value);
+			if (!Number.isFinite(number)) {
+				diagnostics.push(sourceError("Default number literals must be finite", [...path, "default"]));
+				return;
+			}
+			return Object.is(number, -0) ? "0" : String(number);
+		}
+	}
+}
+function printJsonValue(value) {
+	if (value === null) return "null";
+	if (typeof value === "string") return literal(value);
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (typeof value === "number") return Object.is(value, -0) ? "0" : String(value);
+	if (Array.isArray(value)) return `[${value.map(printJsonValue).join(", ")}]`;
+	return `{ ${Object.keys(value).sort().map((key) => `[${literal(key)}]: ${printJsonValue(value[key])}`).join(", ")} }`;
+}
+function applicationType(value) {
+	return value;
+}
+function sqlDomainType(value) {
+	switch (value) {
+		case "unknown": return "_qubu.SqlUnknown";
+		case "integer": return "_qubu.SqlInteger";
+		case "decimal": return "_qubu.SqlDecimal";
+		case "text": return "_qubu.SqlText";
+		case "boolean": return "_qubu.SqlBoolean";
+		case "date": return "_qubu.SqlDate";
+		case "timestamp": return "_qubu.SqlTimestamp";
+		case "uuid": return "_qubu.SqlUuid";
+		case "json": return "_qubu.SqlJson";
+		case "bigint": return "_qubu.SqlBigInt";
+		case "binary": return "_qubu.SqlBinary";
+	}
+}
+function sourceError(message, path) {
+	return {
+		severity: "error",
+		code: "unrepresentable-fact",
+		message,
+		path
+	};
+}
+function literal(value) {
+	return JSON.stringify(value).replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+}
+function capitalize(value) {
+	return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+function indent(value, spaces) {
+	const prefix = " ".repeat(spaces);
+	return value.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/codegen/generate.ts
+const supportedDialects = /* @__PURE__ */ new Set([
+	"postgresql",
+	"sqlite",
+	"mysql"
+]);
+const applicationTypes = /* @__PURE__ */ new Set([
+	"unknown",
+	"string",
+	"number",
+	"boolean",
+	"bigint",
+	"Date",
+	"Uint8Array"
+]);
+const sqlDomains = /* @__PURE__ */ new Set([
+	"unknown",
+	"integer",
+	"decimal",
+	"text",
+	"boolean",
+	"date",
+	"timestamp",
+	"uuid",
+	"json",
+	"bigint",
+	"binary"
+]);
+const orderableDomains = /* @__PURE__ */ new Set([
+	"unknown",
+	"integer",
+	"decimal",
+	"text",
+	"date",
+	"timestamp",
+	"bigint"
+]);
+const reservedBindings = /* @__PURE__ */ new Set([
+	"arguments",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"interface",
+	"instanceof",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+const excludedFamilies = [
+	["views", "views"],
+	["sequences", "sequences"],
+	["enums", "enums"],
+	["domains", "domains"],
+	["collations", "collations"],
+	["triggers", "triggers"],
+	["routines", "routines"],
+	["partitions", "partitions"],
+	["policies", "policies"],
+	["extensionObjects", "extension objects"],
+	["deferredObjects", "deferred objects"],
+	["opaqueObjects", "opaque objects"],
+	["comments", "comments"],
+	["ownership", "ownership records"]
+];
+/**
+* Generate a deterministic TypeScript module from one introspection result.
+*
+* @remarks
+* Generation accepts only a successful, non-lossy Snapshot v1 result for one
+* PostgreSQL, SQLite, or MySQL namespace. It is pure: it opens no connection,
+* performs no filesystem writes, and never evaluates catalog SQL. Existing
+* introspection diagnostics are copied into the result. Any error returns no
+* source.
+*
+* The generated module exports every ordinary table plus one schema registry.
+* Physical names and native declarations remain escaped string literals.
+* Catalog expressions use dialect-tagged schema data, checks use
+* `catalogCheck()`, and foreign keys use lazy `catalogForeignKey()` targets.
+* Foreign keys must have equal local and target arity and target an exact
+* primary key, strict unique key, or candidate index. Nullable database UNIQUE
+* constraints do not provide that candidate-key proof and fail generation.
+*
+* Application output, insert, and update types default independently to
+* `unknown`. The generator may attach a conservative SQL semantic domain, and
+* {@link SchemaCodegenOptions.mapColumn} can override either type axis with a
+* fixed token. Naming callbacks can replace suggested camelCase IDs, but they
+* cannot supply source syntax.
+*
+* @param input A completed introspection operation. Failed and lossy results
+* are reported as diagnostics rather than thrown errors.
+* @param options Controlled logical-name and column-type mappings.
+* @returns Generated source and diagnostics, or diagnostics without source.
+*/
+function generateSchemaSource(input, options = {}) {
+	const diagnostics = [];
+	try {
+		if (!isOptions(options)) {
+			diagnostics.push(errorDiagnostic("invalid-option", "Code generation options must be an object", ["options"]));
+			return failure(diagnostics);
+		}
+		if (!isIntrospectionResult(input)) {
+			diagnostics.push(errorDiagnostic("invalid-input", "Code generation requires an introspection result", []));
+			return failure(diagnostics);
+		}
+		diagnostics.push(...input.diagnostics);
+		appendExcludedFamilyDiagnostics(input.catalog, diagnostics);
+		if (!input.ok) {
+			diagnostics.push(errorDiagnostic("invalid-input", "Code generation requires a successful introspection result", []));
+			return failure(diagnostics);
+		}
+		if (input.lossy) diagnostics.push(errorDiagnostic("lossy-input", "Code generation rejects lossy introspection results", ["lossy"], "Run introspection in strict mode and resolve every reported omission."));
+		if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return failure(diagnostics);
+		const decoded = decodeSchemaSnapshot(input.snapshot);
+		if (!decoded.ok) {
+			diagnostics.push(...decoded.diagnostics.map((diagnostic) => errorDiagnostic("unsupported-snapshot", diagnostic.message, diagnostic.path)));
+			return failure(diagnostics);
+		}
+		const snapshot = decoded.value;
+		validateInputEnvelope(input.catalog, snapshot, diagnostics);
+		validatePhysicalFacts(input.catalog, snapshot, diagnostics);
+		validateSchemaProofs(snapshot, diagnostics);
+		if (hasErrors(diagnostics)) return failure(diagnostics);
+		const resolved = resolveSchema(input.catalog, snapshot, options, diagnostics);
+		if (resolved === void 0 || hasErrors(diagnostics)) return failure(diagnostics);
+		validateResolvedDomains(resolved, diagnostics);
+		if (hasErrors(diagnostics)) return failure(diagnostics);
+		const source = printSchemaSource(resolved, diagnostics);
+		if (source === void 0 || hasErrors(diagnostics)) return failure(diagnostics);
+		return Object.freeze({
+			ok: true,
+			source,
+			diagnostics: freezeDiagnostics(diagnostics)
+		});
+	} catch (caught) {
+		diagnostics.push(errorDiagnostic("unsafe-source", caught instanceof Error ? `Schema source generation failed safely: ${caught.message}` : "Schema source generation failed safely", []));
+		return failure(diagnostics);
+	}
+}
+function validateInputEnvelope(catalog, snapshot, diagnostics) {
+	if (!supportedDialects.has(catalog.dialect)) diagnostics.push(errorDiagnostic("unsupported-snapshot", `Code generation does not support catalog dialect "${catalog.dialect}"`, ["catalog", "dialect"]));
+	if (snapshot.dialect.name !== catalog.dialect) diagnostics.push(errorDiagnostic("unsupported-snapshot", `Snapshot dialect "${snapshot.dialect.name}" does not match catalog dialect "${catalog.dialect}"`, ["snapshot", "dialect"], void 0, [["catalog", "dialect"]]));
+	if (snapshot.dialect.version !== 1) diagnostics.push(errorDiagnostic("unsupported-snapshot", `Code generation supports Snapshot v1 dialect extensions, received version ${snapshot.dialect.version}`, [
+		"snapshot",
+		"dialect",
+		"version"
+	]));
+	if (snapshot.namespace !== catalog.namespace.name) diagnostics.push(errorDiagnostic("unsupported-snapshot", "Snapshot and catalog namespaces do not match", ["snapshot", "namespace"], void 0, [[
+		"catalog",
+		"namespace",
+		"name"
+	]]));
+}
+function validatePhysicalFacts(catalog, snapshot, diagnostics) {
+	const remapped = mapCatalogToSnapshot(catalog, {
+		namespace: catalog.namespace.name,
+		mode: "strict"
+	});
+	if (!remapped.ok) {
+		diagnostics.push(errorDiagnostic("omitted-fact", "The normalized catalog cannot be mapped to a complete strict Snapshot v1", ["catalog", "tables"], "Resolve the strict introspection diagnostics before generating source."));
+		return;
+	}
+	const expected = JSON.stringify(toPhysicalFacts(remapped.snapshot));
+	if (JSON.stringify(toPhysicalFacts(snapshot)) !== expected) diagnostics.push(errorDiagnostic("omitted-fact", "The introspection snapshot does not contain the catalog's complete Snapshot v1 table facts", ["snapshot", "tables"], "Use the snapshot returned with this exact strict catalog result."));
+}
+function validateSchemaProofs(snapshot, diagnostics) {
+	const tables = new Map(snapshot.tables.map((table) => [table.id, table]));
+	for (const table of snapshot.tables) {
+		const columns = new Map(table.columns.map((column) => [column.id, column]));
+		const path = [
+			"snapshot",
+			"tables",
+			table.id
+		];
+		for (const constraint of table.constraints) {
+			if (constraint.kind !== "primary-key" && constraint.kind !== "unique") continue;
+			if (constraint.columns.filter((column) => columns.get(column)?.nullable === true).length > 0) diagnostics.push(errorDiagnostic("unrepresentable-fact", `Strict key constraint "${constraint.physicalName}" contains nullable columns`, [
+				...path,
+				"constraints",
+				constraint.id,
+				"columns"
+			], "Qubu primary and strict unique keys require every column to be non-nullable."));
+		}
+		for (const index of table.indexes) {
+			if (!index.candidateKey) continue;
+			const candidateColumns = candidateIndexColumns(index);
+			if (candidateColumns === void 0 || candidateColumns.some((column) => columns.get(column)?.nullable !== false)) diagnostics.push(errorDiagnostic("unrepresentable-fact", `Index "${index.physicalName}" is marked as a candidate key without an exact non-null column key`, [
+				...path,
+				"indexes",
+				index.id,
+				"candidateKey"
+			]));
+		}
+		for (const constraint of table.constraints) {
+			if (constraint.kind !== "foreign-key") continue;
+			const constraintPath = [
+				...path,
+				"constraints",
+				constraint.id
+			];
+			if (constraint.columns.length !== constraint.target.columns.length) {
+				diagnostics.push(errorDiagnostic("unrepresentable-fact", `Foreign key "${constraint.physicalName}" has unequal local and target arity`, [
+					...constraintPath,
+					"target",
+					"columns"
+				]));
+				continue;
+			}
+			const target = tables.get(constraint.target.table);
+			if (target === void 0) continue;
+			if (!hasCandidateKey(target, constraint.target.columns)) diagnostics.push(errorDiagnostic("unrepresentable-fact", `Foreign key "${constraint.physicalName}" does not target an exact primary key, strict unique key, or candidate index`, [
+				...constraintPath,
+				"target",
+				"columns"
+			], "Nullable UNIQUE constraints are database uniqueness metadata, not Qubu candidate-key proofs."));
+		}
+	}
+}
+function hasCandidateKey(table, targetColumns) {
+	const columns = new Map(table.columns.map((column) => [column.id, column]));
+	if (table.constraints.some((constraint) => (constraint.kind === "primary-key" || constraint.kind === "unique") && constraint.columns.every((column) => columns.get(column)?.nullable === false) && sameColumns(constraint.columns, targetColumns))) return true;
+	return table.indexes.some((index) => {
+		if (!index.candidateKey) return false;
+		const candidateColumns = candidateIndexColumns(index);
+		return candidateColumns !== void 0 && candidateColumns.every((column) => columns.get(column)?.nullable === false) && sameColumns(candidateColumns, targetColumns);
+	});
+}
+function candidateIndexColumns(index) {
+	if (!index.candidateKey || !index.unique || index.predicate !== void 0) return;
+	const columns = [];
+	for (const term of index.terms) {
+		const expression = term.kind === "order" ? term.expression : term;
+		if (expression.kind !== "column") return void 0;
+		columns.push(expression.column);
+	}
+	return columns.length > 0 ? columns : void 0;
+}
+function sameColumns(left, right) {
+	return left.length === right.length && left.every((column, index) => column === right[index]);
+}
+function resolveSchema(catalog, snapshot, options, diagnostics) {
+	const schemaSuggested = `${camelCase(catalog.namespace.name)}Schema`;
+	const schemaName = resolveName({
+		kind: "schema",
+		physicalName: catalog.namespace.name,
+		suggestedName: schemaSuggested
+	}, options, ["schema"], true, diagnostics);
+	const catalogTables = groupUnique(catalog.tables, (table) => table.physicalName, ["catalog", "tables"], diagnostics);
+	const tables = [];
+	const tableNames = /* @__PURE__ */ new Map();
+	for (const table of [...snapshot.tables].sort(comparePhysicalName)) {
+		const catalogTable = catalogTables.get(table.physicalName);
+		if (catalogTable === void 0) {
+			diagnostics.push(errorDiagnostic("omitted-fact", `Snapshot table "${table.physicalName}" is missing from the catalog`, [
+				"snapshot",
+				"tables",
+				table.id
+			]));
+			continue;
+		}
+		const path = [
+			"snapshot",
+			"tables",
+			table.id
+		];
+		const name = resolveName({
+			kind: "table",
+			physicalName: table.physicalName,
+			suggestedName: camelCase(table.physicalName)
+		}, options, path, true, diagnostics);
+		if (name === void 0) continue;
+		addUniqueName(name, path, tableNames, diagnostics);
+		const resolvedTable = resolveTable(table, catalogTable, name, catalog, options, diagnostics);
+		if (resolvedTable !== void 0) tables.push(resolvedTable);
+	}
+	if (schemaName !== void 0) {
+		const tableCollision = tableNames.get(schemaName);
+		if (tableCollision !== void 0) diagnostics.push(errorDiagnostic("name-collision", `Schema export and table export both resolve to "${schemaName}"`, ["schema"], void 0, [tableCollision]));
+	}
+	if (schemaName === void 0 || hasErrors(diagnostics)) return void 0;
+	const orderedTables = tables.sort(compareName);
+	return {
+		name: schemaName,
+		namespace: catalog.namespace.name,
+		dialect: catalog.dialect,
+		tables: orderedTables,
+		tablesBySnapshotId: new Map(orderedTables.map((table) => [table.snapshot.id, table]))
+	};
+}
+function resolveTable(snapshot, catalogTable, tableName, catalog, options, diagnostics) {
+	const columnCatalog = groupUnique(catalogTable.columns, (column) => column.physicalName, [
+		"catalog",
+		"tables",
+		catalogTable.id,
+		"columns"
+	], diagnostics);
+	const columns = [];
+	const columnNames = /* @__PURE__ */ new Map();
+	for (const column of [...snapshot.columns].sort(comparePhysicalName)) {
+		const path = [
+			"snapshot",
+			"tables",
+			snapshot.id,
+			"columns",
+			column.id
+		];
+		const catalogColumn = columnCatalog.get(column.physicalName);
+		if (catalogColumn === void 0) {
+			diagnostics.push(errorDiagnostic("omitted-fact", `Snapshot column "${column.physicalName}" is missing from its catalog table`, path));
+			continue;
+		}
+		if (column.storage?.kind !== "native") {
+			diagnostics.push(errorDiagnostic("unrepresentable-fact", `Introspected column "${column.physicalName}" must retain exact native storage`, [...path, "storage"]));
+			continue;
+		}
+		if (column.storage.dialect !== catalog.dialect) {
+			diagnostics.push(errorDiagnostic("unrepresentable-fact", `Column storage dialect "${column.storage.dialect}" does not match "${catalog.dialect}"`, [
+				...path,
+				"storage",
+				"dialect"
+			]));
+			continue;
+		}
+		if (column.storage.type.trim().length === 0) {
+			diagnostics.push(errorDiagnostic("unrepresentable-fact", "Native storage declarations cannot be empty", [
+				...path,
+				"storage",
+				"type"
+			]));
+			continue;
+		}
+		if (!hasCompleteColumnBehavior(column)) {
+			diagnostics.push(errorDiagnostic("omitted-fact", `Column "${column.physicalName}" omits metadata required to reconstruct its write behavior`, path));
+			continue;
+		}
+		const name = resolveName({
+			kind: "column",
+			physicalName: column.physicalName,
+			suggestedName: camelCase(column.physicalName),
+			tablePhysicalName: snapshot.physicalName,
+			tableName
+		}, options, path, false, diagnostics);
+		if (name === void 0) continue;
+		addUniqueName(name, path, columnNames, diagnostics);
+		const suggestedSqlDomain = inferSqlDomain(catalog.dialect, catalogColumn);
+		const mapping = resolveColumnMapping(catalog, catalogTable.physicalName, tableName, catalogColumn, name, suggestedSqlDomain, options, path, diagnostics);
+		if (mapping === void 0) continue;
+		columns.push({
+			name,
+			snapshot: column,
+			catalog: catalogColumn,
+			output: mapping.output ?? "unknown",
+			insert: mapping.insert ?? "unknown",
+			update: mapping.update ?? "unknown",
+			sqlDomain: mapping.sqlDomain ?? suggestedSqlDomain,
+			explicitSqlDomain: mapping.sqlDomain !== void 0
+		});
+	}
+	const constraints = resolveObjects(snapshot.constraints, "constraint", snapshot, tableName, options, diagnostics);
+	const indexes = resolveObjects(snapshot.indexes, "index", snapshot, tableName, options, diagnostics);
+	if (hasErrors(diagnostics)) return void 0;
+	const orderedColumns = columns.sort(compareName);
+	return {
+		name: tableName,
+		snapshot,
+		catalog: catalogTable,
+		columns: orderedColumns,
+		columnsBySnapshotId: new Map(orderedColumns.map((column) => [column.snapshot.id, column])),
+		constraints,
+		indexes
+	};
+}
+function resolveObjects(objects, kind, table, tableName, options, diagnostics) {
+	const names = /* @__PURE__ */ new Map();
+	const result = [];
+	for (const object of [...objects].sort(comparePhysicalName)) {
+		const path = [
+			"snapshot",
+			"tables",
+			table.id,
+			kind === "constraint" ? "constraints" : "indexes",
+			object.id
+		];
+		const name = resolveName({
+			kind,
+			physicalName: object.physicalName,
+			suggestedName: camelCase(object.physicalName),
+			tablePhysicalName: table.physicalName,
+			tableName
+		}, options, path, false, diagnostics);
+		if (name === void 0) continue;
+		addUniqueName(name, path, names, diagnostics);
+		result.push({
+			name,
+			snapshot: object
+		});
+	}
+	return result.sort(compareName);
+}
+function resolveColumnMapping(catalog, tablePhysicalName, tableName, column, columnName, suggestedSqlDomain, options, path, diagnostics) {
+	if (options.mapColumn === void 0) return {};
+	if (typeof options.mapColumn !== "function") {
+		diagnostics.push(errorDiagnostic("invalid-option", "mapColumn must be a function", ["options", "mapColumn"]));
+		return;
+	}
+	let mapping;
+	try {
+		mapping = options.mapColumn({
+			dialect: catalog.dialect,
+			namespace: catalog.namespace.name,
+			tablePhysicalName,
+			tableName,
+			columnPhysicalName: column.physicalName,
+			columnName,
+			nativeType: column.storage.nativeType,
+			portableType: column.storage.portable?.type,
+			classificationConfidence: column.storage.portable?.confidence,
+			suggestedSqlDomain
+		});
+	} catch (caught) {
+		diagnostics.push(errorDiagnostic("invalid-option", caught instanceof Error ? `Column mapping failed: ${caught.message}` : "Column mapping failed", [...path, "mapping"]));
+		return;
+	}
+	if (mapping === void 0) return {};
+	if (typeof mapping !== "object" || mapping === null || Array.isArray(mapping)) {
+		diagnostics.push(errorDiagnostic("invalid-option", "Column mappings must return an object or undefined", [...path, "mapping"]));
+		return;
+	}
+	for (const axis of [
+		"output",
+		"insert",
+		"update"
+	]) {
+		const value = mapping[axis];
+		if (value !== void 0 && !applicationTypes.has(value)) diagnostics.push(errorDiagnostic("invalid-option", `Unsupported ${axis} application type "${String(value)}"`, [
+			...path,
+			"mapping",
+			axis
+		]));
+	}
+	if (mapping.sqlDomain !== void 0 && !sqlDomains.has(mapping.sqlDomain)) diagnostics.push(errorDiagnostic("invalid-option", `Unsupported SQL domain "${String(mapping.sqlDomain)}"`, [
+		...path,
+		"mapping",
+		"sqlDomain"
+	]));
+	return hasErrors(diagnostics) ? void 0 : mapping;
+}
+function validateResolvedDomains(schema, diagnostics) {
+	for (const table of schema.tables) for (const index of table.indexes) for (const term of index.snapshot.terms) {
+		const ordered = term.kind === "order" ? term : void 0;
+		if (ordered?.expression.kind !== "column") continue;
+		const column = table.columnsBySnapshotId.get(ordered.expression.column);
+		if (column === void 0 || orderableDomains.has(column.sqlDomain)) continue;
+		if (column.explicitSqlDomain) diagnostics.push(errorDiagnostic("invalid-option", `SQL domain "${column.sqlDomain}" cannot represent an ordered index term`, [
+			"snapshot",
+			"tables",
+			table.snapshot.id,
+			"indexes",
+			index.snapshot.id,
+			"terms"
+		]));
+		else column.sqlDomain = "unknown";
+	}
+	for (const table of schema.tables) for (const constraint of table.constraints) {
+		if (constraint.snapshot.kind !== "foreign-key") continue;
+		const targetTable = schema.tablesBySnapshotId.get(constraint.snapshot.target.table);
+		if (targetTable === void 0) continue;
+		for (const [index, localId] of constraint.snapshot.columns.entries()) {
+			const targetId = constraint.snapshot.target.columns[index];
+			const local = table.columnsBySnapshotId.get(localId);
+			const target = targetId ? targetTable.columnsBySnapshotId.get(targetId) : void 0;
+			if (local === void 0 || target === void 0 || local.sqlDomain === "unknown" || target.sqlDomain === "unknown" || local.sqlDomain === target.sqlDomain) continue;
+			if (local.explicitSqlDomain && target.explicitSqlDomain) diagnostics.push(errorDiagnostic("invalid-option", `Mapped foreign-key domains differ: "${local.sqlDomain}" and "${target.sqlDomain}"`, [
+				"snapshot",
+				"tables",
+				table.snapshot.id,
+				"constraints",
+				constraint.snapshot.id,
+				"columns",
+				index
+			]));
+			else if (!local.explicitSqlDomain) local.sqlDomain = "unknown";
+			else target.sqlDomain = "unknown";
+		}
+	}
+}
+function inferSqlDomain(dialect, column) {
+	const portable = column.storage.portable;
+	if (portable?.confidence === "exact") return portableDomain(portable.type);
+	const declaration = column.storage.nativeType.trim().toLowerCase();
+	if (dialect === "postgresql") switch (declaration) {
+		case "smallint":
+		case "integer": return "integer";
+		case "bigint": return "bigint";
+		case "numeric": return "decimal";
+		case "text": return "text";
+		case "boolean": return "boolean";
+		case "date": return "date";
+		case "timestamp without time zone":
+		case "timestamp with time zone": return "timestamp";
+		case "uuid": return "uuid";
+		case "json":
+		case "jsonb": return "json";
+		case "bytea": return "binary";
+		default: return "unknown";
+	}
+	if (dialect === "mysql") switch (declaration) {
+		case "tinyint":
+		case "smallint":
+		case "mediumint":
+		case "int": return "integer";
+		case "bigint": return "bigint";
+		case "decimal": return "decimal";
+		case "text":
+		case "tinytext":
+		case "mediumtext":
+		case "longtext": return "text";
+		case "date": return "date";
+		case "datetime":
+		case "timestamp": return "timestamp";
+		case "json": return "json";
+		case "blob":
+		case "tinyblob":
+		case "mediumblob":
+		case "longblob": return "binary";
+		default: return "unknown";
+	}
+	return "unknown";
+}
+function portableDomain(portable) {
+	return portable === "numeric" ? "decimal" : portable;
+}
+function resolveName(context, options, path, exportBinding, diagnostics) {
+	let name = context.suggestedName;
+	if (options.naming !== void 0) {
+		if (typeof options.naming !== "function") {
+			diagnostics.push(errorDiagnostic("invalid-option", "naming must be a function", ["options", "naming"]));
+			return;
+		}
+		try {
+			name = options.naming(context) ?? context.suggestedName;
+		} catch (caught) {
+			diagnostics.push(errorDiagnostic("invalid-option", caught instanceof Error ? `Naming callback failed: ${caught.message}` : "Naming callback failed", [...path, "name"]));
+			return;
+		}
+	}
+	if (typeof name !== "string" || !/^[a-z][A-Za-z0-9]*$/u.test(name) || exportBinding && reservedBindings.has(name)) {
+		diagnostics.push(errorDiagnostic("unsafe-name", `Physical ${context.kind} name ${JSON.stringify(context.physicalName)} does not resolve to a safe camelCase${exportBinding ? " export" : ""} identifier`, [...path, "name"], "Return a safe camelCase ID from the naming callback."));
+		return;
+	}
+	return name;
+}
+function camelCase(value) {
+	const words = value.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").split(/[^A-Za-z0-9]+/u).filter(Boolean).map((word) => word.toLowerCase());
+	return `${words.shift() ?? ""}${words.map((word) => `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`).join("")}`;
+}
+function hasCompleteColumnBehavior(column) {
+	if ([
+		column.default,
+		column.generatedColumn,
+		column.identity
+	].filter((value) => value !== void 0).length > 1) return false;
+	if (column.generatedColumn !== void 0 || column.identity !== void 0) return column.generated && !column.hasDefault;
+	if (column.default !== void 0) return !column.generated && column.hasDefault;
+	return !column.generated && !column.hasDefault;
+}
+function toPhysicalFacts(snapshot) {
+	const tableById = new Map(snapshot.tables.map((table) => [table.id, table]));
+	const columnNames = new Map(snapshot.tables.map((table) => [table.id, new Map(table.columns.map((column) => [column.id, column.physicalName]))]));
+	return {
+		dialect: snapshot.dialect,
+		namespace: snapshot.namespace ?? null,
+		tables: [...snapshot.tables].sort(comparePhysicalName).map((table) => ({
+			physicalName: table.physicalName,
+			columns: [...table.columns].sort(comparePhysicalName).map((column) => ({
+				...column,
+				id: column.physicalName
+			})),
+			constraints: [...table.constraints].sort(comparePhysicalName).map((constraint) => physicalConstraint(constraint, table, tableById, columnNames)),
+			indexes: [...table.indexes].sort(comparePhysicalName).map((index) => physicalIndex(index, table, columnNames))
+		}))
+	};
+}
+function physicalConstraint(constraint, table, tables, columns) {
+	if (constraint.kind === "check") return {
+		...constraint,
+		id: constraint.physicalName
+	};
+	const localColumns = constraint.columns.map((id) => columns.get(table.id)?.get(id) ?? `missing:${id}`);
+	if (constraint.kind !== "foreign-key") return {
+		...constraint,
+		id: constraint.physicalName,
+		columns: localColumns
+	};
+	const targetTable = tables.get(constraint.target.table);
+	return {
+		...constraint,
+		id: constraint.physicalName,
+		columns: localColumns,
+		target: {
+			table: targetTable?.physicalName ?? `missing:${constraint.target.table}`,
+			columns: constraint.target.columns.map((id) => columns.get(constraint.target.table)?.get(id) ?? `missing:${id}`)
+		}
+	};
+}
+function physicalIndex(index, table, columns) {
+	const names = columns.get(table.id);
+	return {
+		...index,
+		id: index.physicalName,
+		terms: index.terms.map((term) => physicalIndexTerm(term, names)),
+		...index.includedColumns === void 0 ? {} : { includedColumns: index.includedColumns.map((id) => names?.get(id) ?? `missing:${id}`) }
+	};
+}
+function physicalIndexTerm(term, columns) {
+	if (term.kind === "column") return {
+		...term,
+		column: columns?.get(term.column) ?? `missing:${term.column}`
+	};
+	if (term.kind === "expression") return term;
+	return {
+		...term,
+		expression: term.expression.kind === "column" ? {
+			...term.expression,
+			column: columns?.get(term.expression.column) ?? `missing:${term.expression.column}`
+		} : term.expression
+	};
+}
+function appendExcludedFamilyDiagnostics(catalog, diagnostics) {
+	if (catalog === void 0) return;
+	for (const [property, label] of excludedFamilies) {
+		const values = catalog[property];
+		if (values === void 0 || values.length === 0) continue;
+		diagnostics.push({
+			severity: "warning",
+			code: "excluded-object-family",
+			message: `Snapshot v1 source generation excludes ${values.length} ${label}`,
+			path: Object.freeze(["catalog", property]),
+			remediation: "Use the complete normalized catalog or Snapshot v2 for this object family."
+		});
+	}
+}
+function groupUnique(values, keyOf, path, diagnostics) {
+	const result = /* @__PURE__ */ new Map();
+	for (const [index, value] of values.entries()) {
+		const key = keyOf(value);
+		if (result.has(key)) diagnostics.push(errorDiagnostic("name-collision", `Physical name ${JSON.stringify(key)} occurs more than once`, [...path, index]));
+		else result.set(key, value);
+	}
+	return result;
+}
+function addUniqueName(name, path, names, diagnostics) {
+	const existing = names.get(name);
+	if (existing === void 0) {
+		names.set(name, path);
+		return;
+	}
+	diagnostics.push(errorDiagnostic("name-collision", `More than one physical object resolves to logical ID "${name}"`, [...path, "name"], "Override one logical ID with the naming callback.", [existing]));
+}
+function errorDiagnostic(code, message, path, remediation, relatedPaths) {
+	return {
+		severity: "error",
+		code,
+		message,
+		path,
+		...remediation === void 0 ? {} : { remediation },
+		...relatedPaths === void 0 ? {} : { relatedPaths }
+	};
+}
+function failure(diagnostics) {
+	return Object.freeze({
+		ok: false,
+		diagnostics: freezeDiagnostics(diagnostics)
+	});
+}
+function freezeDiagnostics(diagnostics) {
+	return Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
+		...diagnostic,
+		path: Object.freeze([...diagnostic.path]),
+		relatedPaths: diagnostic.relatedPaths === void 0 ? void 0 : Object.freeze(diagnostic.relatedPaths.map((path) => Object.freeze([...path])))
+	})));
+}
+function hasErrors(diagnostics) {
+	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+function comparePhysicalName(left, right) {
+	return left.physicalName < right.physicalName ? -1 : left.physicalName > right.physicalName ? 1 : 0;
+}
+function compareName(left, right) {
+	return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+}
+function isOptions(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIntrospectionResult(value) {
+	return typeof value === "object" && value !== null && "ok" in value && typeof value.ok === "boolean" && "lossy" in value && typeof value.lossy === "boolean" && "diagnostics" in value && Array.isArray(value.diagnostics);
+}
+//#endregion
+export { generateSchemaSource };