@prisma-next/family-sql 0.3.0-pr.99.6 → 0.4.0-dev.1

package/dist/control.mjs

@@ -0,0 +1,643 @@
+import { n as sqlFamilyAuthoringFieldPresets, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-DgU-RFaP.mjs";
+import { c as assembleControlMutationDefaultContributions, l as assemblePslInterpretationContributions, o as collectInitDependencies, s as isDatabaseDependencyProvider, t as verifySqlSchema, u as extractCodecControlHooks } from "./verify-sql-schema-lR-tlboL.mjs";
+import { r as readMarker, t as collectSupportedCodecTypeIds } from "./verify-DZHtfcmj.mjs";
+import { sqlEmission } from "@prisma-next/sql-contract-emitter";
+import { emptyCodecLookup } from "@prisma-next/framework-components/codec";
+import { SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
+import { validateContract } from "@prisma-next/sql-contract/validate";
+import { ensureSchemaStatement, ensureTableStatement, writeContractMarker } from "@prisma-next/sql-runtime";
+import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { notOk, ok } from "@prisma-next/utils/result";
+
+//#region src/core/control-instance.ts
+function extractCodecTypeIdsFromContract(contract) {
+	const typeIds = /* @__PURE__ */ new Set();
+	if (typeof contract === "object" && contract !== null && "storage" in contract && typeof contract.storage === "object" && contract.storage !== null && "tables" in contract.storage) {
+		const storage = contract.storage;
+		if (storage.tables && typeof storage.tables === "object") {
+			for (const table of Object.values(storage.tables)) if (typeof table === "object" && table !== null && "columns" in table && typeof table.columns === "object" && table.columns !== null) {
+				const columns = table.columns;
+				for (const column of Object.values(columns)) if (column && typeof column === "object" && "codecId" in column && typeof column.codecId === "string") typeIds.add(column.codecId);
+			}
+		}
+	}
+	return Array.from(typeIds).sort();
+}
+function createVerifyResult(options) {
+	const contract = { storageHash: options.contractStorageHash };
+	if (options.contractProfileHash) contract.profileHash = options.contractProfileHash;
+	const target = { expected: options.expectedTargetId };
+	if (options.actualTargetId) target.actual = options.actualTargetId;
+	const meta = { contractPath: options.contractPath };
+	if (options.configPath) meta.configPath = options.configPath;
+	const result = {
+		ok: options.ok,
+		summary: options.summary,
+		contract,
+		target,
+		meta,
+		timings: { total: options.totalTime }
+	};
+	if (options.code) result.code = options.code;
+	if (options.marker) result.marker = {
+		storageHash: options.marker.storageHash,
+		profileHash: options.marker.profileHash
+	};
+	if (options.missingCodecs) result.missingCodecs = options.missingCodecs;
+	if (options.codecCoverageSkipped) result.codecCoverageSkipped = options.codecCoverageSkipped;
+	return result;
+}
+function isSqlControlAdapter(value) {
+	return typeof value === "object" && value !== null && "introspect" in value && typeof value.introspect === "function";
+}
+function buildSqlTypeMetadataRegistry(options) {
+	const { target, adapter, extensionPacks: extensions } = options;
+	const registry = /* @__PURE__ */ new Map();
+	const targetId = adapter.targetId;
+	const descriptors = [
+		target,
+		adapter,
+		...extensions
+	];
+	for (const descriptor of descriptors) {
+		const storageTypes = descriptor.types?.storage;
+		if (!storageTypes) continue;
+		for (const storageType of storageTypes) if (storageType.familyId === "sql" && storageType.targetId === targetId) registry.set(storageType.typeId, {
+			typeId: storageType.typeId,
+			familyId: "sql",
+			targetId: storageType.targetId,
+			...storageType.nativeType !== void 0 ? { nativeType: storageType.nativeType } : {}
+		});
+	}
+	return registry;
+}
+function createSqlFamilyInstance(stack) {
+	if (!stack.adapter) throw new Error("SQL family requires an adapter descriptor in ControlStack");
+	const target = stack.target;
+	const adapter = stack.adapter;
+	const extensions = stack.extensionPacks;
+	const { codecTypeImports, operationTypeImports, extensionIds } = stack;
+	const typeMetadataRegistry = buildSqlTypeMetadataRegistry({
+		target,
+		adapter,
+		extensionPacks: extensions
+	});
+	return {
+		familyId: "sql",
+		codecTypeImports,
+		operationTypeImports,
+		extensionIds,
+		typeMetadataRegistry,
+		validateContract(contractJson) {
+			return validateContract(contractJson, emptyCodecLookup);
+		},
+		async verify(verifyOptions) {
+			const { driver, contract: rawContract, expectedTargetId, contractPath, configPath } = verifyOptions;
+			const startTime = Date.now();
+			const contract = validateContract(rawContract, emptyCodecLookup);
+			const contractStorageHash = contract.storage.storageHash;
+			const contractProfileHash = contract.profileHash;
+			const contractTarget = contract.target;
+			const marker = await readMarker(driver);
+			let missingCodecs;
+			let codecCoverageSkipped = false;
+			const supportedTypeIds = collectSupportedCodecTypeIds([
+				adapter,
+				target,
+				...extensions
+			]);
+			if (supportedTypeIds.length === 0) codecCoverageSkipped = true;
+			else {
+				const supportedSet = new Set(supportedTypeIds);
+				const missing = extractCodecTypeIdsFromContract(contract).filter((id) => !supportedSet.has(id));
+				if (missing.length > 0) missingCodecs = missing;
+			}
+			if (!marker) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_MARKER_MISSING,
+				summary: "Marker missing",
+				contractStorageHash,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (contractTarget !== expectedTargetId) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_TARGET_MISMATCH,
+				summary: "Target mismatch",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				actualTargetId: contractTarget,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (marker.storageHash !== contractStorageHash) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (contractProfileHash && marker.profileHash !== contractProfileHash) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				contractStorageHash,
+				contractProfileHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			return createVerifyResult({
+				ok: true,
+				summary: "Database matches contract",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+		},
+		async schemaVerify(options) {
+			const { driver, contract: contractInput, strict, context, frameworkComponents } = options;
+			const contract = validateContract(contractInput, emptyCodecLookup);
+			const controlAdapter = adapter.create();
+			if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter.introspect()");
+			return verifySqlSchema({
+				contract,
+				schema: await controlAdapter.introspect(driver, contractInput),
+				strict,
+				...ifDefined("context", context),
+				typeMetadataRegistry,
+				frameworkComponents,
+				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
+				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType)
+			});
+		},
+		async sign(options) {
+			const { driver, contract: contractInput, contractPath, configPath } = options;
+			const startTime = Date.now();
+			const contract = validateContract(contractInput, emptyCodecLookup);
+			const contractStorageHash = contract.storage.storageHash;
+			const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : contractStorageHash;
+			const contractTarget = contract.target;
+			await driver.query(ensureSchemaStatement.sql, ensureSchemaStatement.params);
+			await driver.query(ensureTableStatement.sql, ensureTableStatement.params);
+			const existingMarker = await readMarker(driver);
+			let markerCreated = false;
+			let markerUpdated = false;
+			let previousHashes;
+			if (!existingMarker) {
+				const write = writeContractMarker({
+					storageHash: contractStorageHash,
+					profileHash: contractProfileHash,
+					contractJson: contractInput,
+					canonicalVersion: 1
+				});
+				await driver.query(write.insert.sql, write.insert.params);
+				markerCreated = true;
+			} else {
+				const existingStorageHash = existingMarker.storageHash;
+				const existingProfileHash = existingMarker.profileHash;
+				if (!(existingStorageHash === contractStorageHash) || !(existingProfileHash === contractProfileHash)) {
+					previousHashes = {
+						storageHash: existingStorageHash,
+						profileHash: existingProfileHash
+					};
+					const write = writeContractMarker({
+						storageHash: contractStorageHash,
+						profileHash: contractProfileHash,
+						contractJson: contractInput,
+						canonicalVersion: existingMarker.canonicalVersion ?? 1
+					});
+					await driver.query(write.update.sql, write.update.params);
+					markerUpdated = true;
+				}
+			}
+			let summary;
+			if (markerCreated) summary = "Database signed (marker created)";
+			else if (markerUpdated) summary = `Database signed (marker updated from ${previousHashes?.storageHash ?? "unknown"})`;
+			else summary = "Database already signed with this contract";
+			const totalTime = Date.now() - startTime;
+			return {
+				ok: true,
+				summary,
+				contract: {
+					storageHash: contractStorageHash,
+					profileHash: contractProfileHash
+				},
+				target: {
+					expected: contractTarget,
+					actual: contractTarget
+				},
+				marker: {
+					created: markerCreated,
+					updated: markerUpdated,
+					...previousHashes ? { previous: previousHashes } : {}
+				},
+				meta: {
+					contractPath,
+					...configPath ? { configPath } : {}
+				},
+				timings: { total: totalTime }
+			};
+		},
+		async readMarker(options) {
+			return readMarker(options.driver);
+		},
+		async introspect(options) {
+			const { driver, contract } = options;
+			const controlAdapter = adapter.create();
+			if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter.introspect()");
+			return controlAdapter.introspect(driver, contract);
+		},
+		toSchemaView(schema) {
+			const tableNodes = Object.entries(schema.tables).map(([tableName, table]) => {
+				const children = [];
+				const columnNodes = [];
+				for (const [columnName, column] of Object.entries(table.columns)) {
+					const label = `${columnName}: ${column.nativeType} (${column.nullable ? "nullable" : "not nullable"})`;
+					columnNodes.push(new SchemaTreeNode({
+						kind: "field",
+						id: `column-${tableName}-${columnName}`,
+						label,
+						meta: {
+							nativeType: column.nativeType,
+							nullable: column.nullable,
+							...ifDefined("default", column.default)
+						}
+					}));
+				}
+				if (columnNodes.length > 0) children.push(new SchemaTreeNode({
+					kind: "collection",
+					id: `columns-${tableName}`,
+					label: "columns",
+					children: columnNodes
+				}));
+				if (table.primaryKey) {
+					const pkColumns = table.primaryKey.columns.join(", ");
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `primary-key-${tableName}`,
+						label: `primary key: ${pkColumns}`,
+						meta: {
+							columns: table.primaryKey.columns,
+							...table.primaryKey.name ? { name: table.primaryKey.name } : {}
+						}
+					}));
+				}
+				for (const unique of table.uniques) {
+					const name = unique.name ?? `${tableName}_${unique.columns.join("_")}_unique`;
+					const label = `unique ${name}`;
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `unique-${tableName}-${name}`,
+						label,
+						meta: {
+							columns: unique.columns,
+							unique: true
+						}
+					}));
+				}
+				for (const index of table.indexes) {
+					const name = index.name ?? defaultIndexName(tableName, index.columns);
+					const label = index.unique ? `unique index ${name}` : `index ${name}`;
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `index-${tableName}-${name}`,
+						label,
+						meta: {
+							columns: index.columns,
+							unique: index.unique
+						}
+					}));
+				}
+				const tableMeta = {};
+				if (table.primaryKey) {
+					tableMeta["primaryKey"] = table.primaryKey.columns;
+					if (table.primaryKey.name) tableMeta["primaryKeyName"] = table.primaryKey.name;
+				}
+				if (table.foreignKeys.length > 0) tableMeta["foreignKeys"] = table.foreignKeys.map((fk) => ({
+					columns: fk.columns,
+					referencedTable: fk.referencedTable,
+					referencedColumns: fk.referencedColumns,
+					...fk.name ? { name: fk.name } : {}
+				}));
+				return new SchemaTreeNode({
+					kind: "entity",
+					id: `table-${tableName}`,
+					label: `table ${tableName}`,
+					...Object.keys(tableMeta).length > 0 ? { meta: tableMeta } : {},
+					...children.length > 0 ? { children } : {}
+				});
+			});
+			const dependencyNodes = schema.dependencies.map((dep) => {
+				const shortName = dep.id.split(".").pop() ?? dep.id;
+				return new SchemaTreeNode({
+					kind: "dependency",
+					id: `dependency-${dep.id}`,
+					label: `${shortName} dependency is installed`
+				});
+			});
+			const rootChildren = [...tableNodes, ...dependencyNodes];
+			return { root: new SchemaTreeNode({
+				kind: "root",
+				id: "sql-schema",
+				label: "database",
+				...rootChildren.length > 0 ? { children: rootChildren } : {}
+			}) };
+		}
+	};
+}
+
+//#endregion
+//#region src/core/control-descriptor.ts
+var SqlFamilyDescriptor = class {
+	kind = "family";
+	id = "sql";
+	familyId = "sql";
+	version = "0.0.1";
+	emission = sqlEmission;
+	authoring = {
+		field: sqlFamilyAuthoringFieldPresets,
+		type: sqlFamilyAuthoringTypes
+	};
+	create(stack) {
+		return createSqlFamilyInstance(stack);
+	}
+};
+
+//#endregion
+//#region src/core/migrations/contract-to-schema-ir.ts
+function convertColumn(name, column, expandNativeType, renderDefault) {
+	return {
+		name,
+		nativeType: expandNativeType ? expandNativeType({
+			nativeType: column.nativeType,
+			codecId: column.codecId,
+			...ifDefined("typeParams", column.typeParams)
+		}) : column.nativeType,
+		nullable: column.nullable,
+		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0)
+	};
+}
+function convertUnique(unique) {
+	return {
+		columns: unique.columns,
+		...ifDefined("name", unique.name)
+	};
+}
+function convertIndex(index) {
+	return {
+		columns: index.columns,
+		unique: false,
+		...ifDefined("name", index.name)
+	};
+}
+function convertForeignKey(fk) {
+	return {
+		columns: fk.columns,
+		referencedTable: fk.references.table,
+		referencedColumns: fk.references.columns,
+		...ifDefined("name", fk.name)
+	};
+}
+function convertTable(name, table, expandNativeType, renderDefault) {
+	const columns = {};
+	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, expandNativeType, renderDefault);
+	const satisfiedIndexColumns = new Set([
+		...table.indexes.map((idx) => idx.columns.join(",")),
+		...table.uniques.map((unique) => unique.columns.join(",")),
+		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
+	]);
+	const fkBackingIndexes = [];
+	for (const fk of table.foreignKeys) {
+		if (fk.index === false) continue;
+		const key = fk.columns.join(",");
+		if (satisfiedIndexColumns.has(key)) continue;
+		fkBackingIndexes.push({
+			columns: fk.columns,
+			unique: false,
+			name: defaultIndexName(name, fk.columns)
+		});
+		satisfiedIndexColumns.add(key);
+	}
+	return {
+		name,
+		columns,
+		...ifDefined("primaryKey", table.primaryKey),
+		foreignKeys: table.foreignKeys.map(convertForeignKey),
+		uniques: table.uniques.map(convertUnique),
+		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes]
+	};
+}
+/**
+* Detects destructive changes between two contract storages.
+*
+* The additive-only planner silently ignores removals (tables, columns).
+* This function detects those removals so callers can report them as conflicts
+* rather than silently producing an empty plan.
+*
+* Returns an empty array if no destructive changes are found.
+*/
+function detectDestructiveChanges(from, to) {
+	if (!from) return [];
+	const hasOwn = (value, key) => Object.hasOwn(value, key);
+	const conflicts = [];
+	for (const tableName of Object.keys(from.tables)) {
+		if (!hasOwn(to.tables, tableName)) {
+			conflicts.push({
+				kind: "tableRemoved",
+				summary: `Table "${tableName}" was removed`
+			});
+			continue;
+		}
+		const toTable = to.tables[tableName];
+		const fromTable = from.tables[tableName];
+		if (!fromTable) continue;
+		for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
+			kind: "columnRemoved",
+			summary: `Column "${tableName}"."${columnName}" was removed`
+		});
+	}
+	return conflicts;
+}
+/**
+* Converts a `Contract` to `SqlSchemaIR`.
+*
+* Reads `contract.storage` for tables, `contract.storage.types` for type
+* annotations, and derives database dependencies from `frameworkComponents`
+* (each component's `databaseDependencies.init[].id`).
+* Storage-type annotations are written under `options.annotationNamespace`.
+*
+* Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
+* structural information. When `expandNativeType` is provided, parameterized types
+* are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
+* resulting IR compares correctly against the "to" contract during planning.
+*
+* Returns an empty schema IR when `contract` is `null` (new project).
+*/
+function contractToSchemaIR(contract, options) {
+	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
+	if (!contract) return {
+		tables: {},
+		dependencies: []
+	};
+	const storage = contract.storage;
+	const tables = {};
+	for (const [tableName, tableDef] of Object.entries(storage.tables)) tables[tableName] = convertTable(tableName, tableDef, options.expandNativeType, options.renderDefault);
+	return {
+		tables,
+		dependencies: deduplicateDependencyIRs(collectInitDependencies(options.frameworkComponents ?? [])),
+		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace))
+	};
+}
+function deduplicateDependencyIRs(deps) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const dep of deps) {
+		if (dep.id.trim().length === 0) throw new Error("Dependency id must be a non-empty string");
+		if (seen.has(dep.id)) continue;
+		seen.add(dep.id);
+		result.push({ id: dep.id });
+	}
+	return result;
+}
+function deriveAnnotations(storage, annotationNamespace) {
+	if (!storage.types || Object.keys(storage.types).length === 0) return void 0;
+	const byNativeType = {};
+	for (const typeInstance of Object.values(storage.types)) byNativeType[typeInstance.nativeType] = typeInstance;
+	return { [annotationNamespace]: { storageTypes: byNativeType } };
+}
+
+//#endregion
+//#region src/core/migrations/plan-helpers.ts
+const readOnlyEmptyObject = Object.freeze({});
+function cloneRecord(value) {
+	if (value === readOnlyEmptyObject) return value;
+	return Object.freeze({ ...value });
+}
+function freezeSteps(steps) {
+	if (steps.length === 0) return Object.freeze([]);
+	return Object.freeze(steps.map((step) => Object.freeze({
+		description: step.description,
+		sql: step.sql,
+		...step.meta ? { meta: cloneRecord(step.meta) } : {}
+	})));
+}
+function freezeDetailsValue(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "object") return value;
+	if (Array.isArray(value)) return Object.freeze([...value]);
+	return Object.freeze({ ...value });
+}
+function freezeTargetDetails(target) {
+	return Object.freeze({
+		id: target.id,
+		...target.details !== void 0 ? { details: freezeDetailsValue(target.details) } : {}
+	});
+}
+function freezeOperation(operation) {
+	return Object.freeze({
+		id: operation.id,
+		label: operation.label,
+		...operation.summary ? { summary: operation.summary } : {},
+		operationClass: operation.operationClass,
+		target: freezeTargetDetails(operation.target),
+		precheck: freezeSteps(operation.precheck),
+		execute: freezeSteps(operation.execute),
+		postcheck: freezeSteps(operation.postcheck),
+		...operation.meta ? { meta: cloneRecord(operation.meta) } : {}
+	});
+}
+function freezeOperations(operations) {
+	if (operations.length === 0) return Object.freeze([]);
+	return Object.freeze(operations.map((operation) => freezeOperation(operation)));
+}
+function createMigrationPlan(options) {
+	return Object.freeze({
+		targetId: options.targetId,
+		...options.origin !== void 0 ? { origin: options.origin ? Object.freeze({ ...options.origin }) : null } : {},
+		destination: Object.freeze({ ...options.destination }),
+		operations: freezeOperations(options.operations),
+		...options.meta ? { meta: cloneRecord(options.meta) } : {}
+	});
+}
+function plannerSuccess(plan) {
+	return Object.freeze({
+		kind: "success",
+		plan
+	});
+}
+function plannerFailure(conflicts) {
+	return Object.freeze({
+		kind: "failure",
+		conflicts: Object.freeze(conflicts.map((conflict) => Object.freeze({
+			kind: conflict.kind,
+			summary: conflict.summary,
+			...conflict.why ? { why: conflict.why } : {},
+			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+		})))
+	});
+}
+/**
+* Creates a successful migration runner result.
+*/
+function runnerSuccess(value) {
+	return ok(Object.freeze({
+		operationsPlanned: value.operationsPlanned,
+		operationsExecuted: value.operationsExecuted
+	}));
+}
+/**
+* Creates a failed migration runner result.
+*/
+function runnerFailure(code, summary, options) {
+	return notOk(Object.freeze({
+		code,
+		summary,
+		...options?.why ? { why: options.why } : {},
+		...options?.meta ? { meta: cloneRecord(options.meta) } : {}
+	}));
+}
+
+//#endregion
+//#region src/core/migrations/policies.ts
+/**
+* Policy used by `db init`: additive-only operations, no widening/destructive steps.
+*/
+const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.freeze(["additive"]) });
+
+//#endregion
+//#region src/exports/control.ts
+var control_default = new SqlFamilyDescriptor();
+
+//#endregion
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, assembleControlMutationDefaultContributions, assemblePslInterpretationContributions, collectInitDependencies, contractToSchemaIR, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, isDatabaseDependencyProvider, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess };
+//# sourceMappingURL=control.mjs.map