@prisma-next/target-sqlite 0.14.0-dev.49 → 0.14.0-dev.50

package/dist/planner-EoQcJGzv.mjs

@@ -1,676 +0,0 @@
-import { t as parseSqliteDefault } from "./default-normalizer-DuoHj9-O.mjs";
-import { t as normalizeSqliteNativeType } from "./native-type-normalizer-CiSyVmMP.mjs";
-import { _ as resolveColumnTypeMetadata, a as DropColumnCall, d as buildRecreateSummary, g as renderDefaultLiteral, h as isInlineAutoincrementPrimaryKey, i as DataTransformCall, l as RecreateTableCall, m as buildColumnTypeSql, n as CreateIndexCall, o as DropIndexCall, p as buildColumnDefaultSql, r as CreateTableCall, s as DropTableCall, t as AddColumnCall, u as buildRecreatePostchecks } from "./op-factory-call-CMBTpb4M.mjs";
-import { t as CONTROL_TABLE_NAMES } from "./control-tables-7KwMyJ6i.mjs";
-import { t as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-BSjMKJhI.mjs";
-import { DdlColumn, ForeignKeyConstraint, FunctionColumnDefault, LiteralColumnDefault, PrimaryKeyConstraint, UniqueConstraint } from "@prisma-next/sql-relational-core/ast";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { contractToSchemaIR, extractCodecControlHooks, planFieldEventOperations, plannerFailure } from "@prisma-next/family-sql/control";
-import { verifySqlSchemaTree } from "@prisma-next/family-sql/diff";
-import { SchemaDiff } from "@prisma-next/framework-components/control";
-import { blindCast } from "@prisma-next/utils/casts";
-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/migrations/diff-database-schema.ts
-/** Renders a column default for the SQLite dialect. */
-function sqliteRenderDefault(def, _column) {
-	if (def.kind === "function") {
-		if (def.expression === "now()") return "datetime('now')";
-		return def.expression;
-	}
-	return renderDefaultLiteral(def.value);
-}
-/** The SQLite expected-side projection: contract → flat relational schema IR. */
-function sqliteContractToSchema(contract) {
-	return contractToSchemaIR(contract, {
-		annotationNamespace: "sqlite",
-		renderDefault: sqliteRenderDefault
-	});
-}
-function computeSqliteSchemaComparison(input) {
-	return verifySqlSchemaTree({
-		contract: input.contract,
-		actualSchema: input.actualSchema,
-		buildExpectedSchema: sqliteContractToSchema,
-		strict: input.strict,
-		typeMetadataRegistry: input.typeMetadataRegistry,
-		frameworkComponents: input.frameworkComponents,
-		normalizeDefault: parseSqliteDefault,
-		normalizeNativeType: normalizeSqliteNativeType
-	});
-}
-/**
-* The SQLite `SchemaDiffer` — relational only. SQLite has a single flat
-* schema and no structural (policy) diff, so it runs the shared per-schema
-* relational diff and returns no `schemaDiffIssues`.
-*/
-function diffSqliteDatabaseSchema(input) {
-	const relational = computeSqliteSchemaComparison(input);
-	return new SchemaDiff(relational.schema.issues, relational.schema.schemaDiffIssues);
-}
-/**
-* The same comparison as {@link diffSqliteDatabaseSchema}, wrapped in the
-* verify envelope (`ok`/`summary`/`code`/`target`/`timings`) plus the
-* pass/warn/fail tree the CLI renders.
-*/
-function verifySqliteDatabaseSchema(input) {
-	return computeSqliteSchemaComparison(input);
-}
-//#endregion
-//#region src/core/migrations/planner-strategies.ts
-/**
-* Look up a storage table by its explicit namespace coordinate. Returns
-* `undefined` when the namespace has no table by that name (or no such
-* namespace exists). Callers that get `undefined` MUST treat it as an
-* explicit conflict rather than silently falling back to a name-only
-* walk across namespaces — the SQLite target currently has a single
-* namespace, but this helper enforces the explicit-coordinate
-* discipline so a future multi-namespace SQLite shape inherits the
-* conflict-on-stale-coordinate behaviour the Postgres planner already
-* has.
-*/
-function tableAt(storage, namespaceId, tableName) {
-	const ns = storage.namespaces[namespaceId];
-	return ns !== void 0 ? ns.entries.table?.[tableName] : void 0;
-}
-/**
-* Default namespace coordinate for an issue that does not carry one
-* explicitly. Hand-crafted unit-test issues fall back to `__unbound__`,
-* the only namespace any single-namespace contract carries —
-* verifier-emitted issues for legacy single-namespace contracts already
-* stamp this id explicitly. Typed structurally so issue variants
-* without a `namespaceId` slot flow through to the same fallback.
-*/
-function resolveNamespaceIdForIssue(issue) {
-	return issue.namespaceId ?? UNBOUND_NAMESPACE_ID;
-}
-const WIDENING_ISSUE_KINDS = new Set(["default_mismatch", "default_missing"]);
-const DESTRUCTIVE_ISSUE_KINDS = new Set([
-	"extra_default",
-	"type_mismatch",
-	"primary_key_mismatch",
-	"foreign_key_mismatch",
-	"unique_constraint_mismatch",
-	"extra_foreign_key",
-	"extra_unique_constraint",
-	"extra_primary_key"
-]);
-function classifyIssue(issue) {
-	if (issue.kind === "enum_values_changed") return null;
-	if (!issue.table) return null;
-	if (issue.kind === "nullability_mismatch") return issue.expected === "true" ? "widening" : "destructive";
-	if (WIDENING_ISSUE_KINDS.has(issue.kind)) return "widening";
-	if (DESTRUCTIVE_ISSUE_KINDS.has(issue.kind)) return "destructive";
-	return null;
-}
-/**
-* Groups recreate-eligible issues by table, decides per-table operation class
-* (destructive wins over widening), and emits one `RecreateTableCall` per
-* table. Returns unchanged-or-smaller issue list — issues the strategy
-* consumed are removed so `mapIssueToCall` doesn't double-handle them.
-*/
-const recreateTableStrategy = (issues, ctx) => {
-	const byTable = /* @__PURE__ */ new Map();
-	const consumed = /* @__PURE__ */ new Set();
-	for (const issue of issues) {
-		const cls = classifyIssue(issue);
-		if (!cls) continue;
-		if (issue.kind === "enum_values_changed") continue;
-		if (!issue.table) continue;
-		const table = issue.table;
-		const entry = byTable.get(table);
-		if (entry) {
-			entry.issues.push(issue);
-			if (cls === "destructive") entry.hasDestructive = true;
-		} else byTable.set(table, {
-			issues: [issue],
-			hasDestructive: cls === "destructive",
-			namespaceId: resolveNamespaceIdForIssue(issue)
-		});
-		consumed.add(issue);
-	}
-	if (byTable.size === 0) return { kind: "no_match" };
-	const calls = [];
-	for (const [tableName, entry] of byTable) {
-		const contractTable = tableAt(ctx.toContract.storage, entry.namespaceId, tableName);
-		const schemaTable = ctx.schema.tables[tableName];
-		if (!contractTable || !schemaTable) continue;
-		const operationClass = entry.hasDestructive ? "destructive" : "widening";
-		const tableSpec = toTableSpec(contractTable, ctx.storageTypes);
-		const seenIndexColumnKeys = /* @__PURE__ */ new Set();
-		const indexes = [];
-		for (const idx of contractTable.indexes) {
-			const key = idx.columns.join(",");
-			if (seenIndexColumnKeys.has(key)) continue;
-			seenIndexColumnKeys.add(key);
-			indexes.push({
-				name: idx.name ?? defaultIndexName(tableName, idx.columns),
-				columns: idx.columns
-			});
-		}
-		for (const fk of contractTable.foreignKeys) {
-			if (fk.index === false) continue;
-			const key = fk.source.columns.join(",");
-			if (seenIndexColumnKeys.has(key)) continue;
-			seenIndexColumnKeys.add(key);
-			indexes.push({
-				name: defaultIndexName(tableName, fk.source.columns),
-				columns: fk.source.columns
-			});
-		}
-		calls.push(new RecreateTableCall({
-			tableName,
-			contractTable: tableSpec,
-			schemaColumnNames: Object.keys(schemaTable.columns),
-			indexes,
-			summary: buildRecreateSummary(tableName, entry.issues),
-			postchecks: buildRecreatePostchecks(tableName, entry.issues, tableSpec),
-			operationClass
-		}));
-	}
-	return {
-		kind: "match",
-		issues: issues.filter((i) => !consumed.has(i)),
-		calls,
-		recipe: true
-	};
-};
-/**
-* When the policy allows `'data'` and the contract tightens one or more
-* columns from nullable to NOT NULL, emit a `DataTransformCall` stub per
-* tightened column. The user fills the backfill `UPDATE` in the rendered
-* `migration.ts` before the subsequent `RecreateTableCall` copies data into
-* the tightened schema (whose `INSERT INTO temp SELECT … FROM old` would
-* otherwise fail at runtime if any `NULL`s remain).
-*
-* Does NOT consume the tightening issue — `recreateTableStrategy` still
-* needs it to produce the actual recreate that enforces the NOT NULL at
-* the schema level. The backfill op and the recreate op end up in the
-* recipe slot in strategy order (backfill first, recreate second), which
-* matches the required execution order.
-*
-* Mirrors Postgres's `nullableTighteningCallStrategy` / `'data'`-class
-* gating. When `'data'` is not in the policy (the default `db update` /
-* `db init` path), the strategy short-circuits and the recreate alone
-* runs with its current destructive-class gating — preserving today's
-* behavior where a tightening blows up at runtime if NULLs are present.
-*/
-const nullabilityTighteningBackfillStrategy = (issues, ctx) => {
-	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
-	const calls = [];
-	for (const issue of issues) {
-		if (issue.kind !== "nullability_mismatch") continue;
-		if (!issue.table || !issue.column) continue;
-		if (issue.expected === "true") continue;
-		const namespaceId = resolveNamespaceIdForIssue(issue);
-		const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
-		if (!column || column.nullable === true) continue;
-		calls.push(new DataTransformCall(`data_migration.backfill-${issue.table}-${issue.column}`, `Backfill NULLs in "${issue.table}"."${issue.column}" before NOT NULL tightening`, issue.table, issue.column));
-	}
-	if (calls.length === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues,
-		calls,
-		recipe: true
-	};
-};
-const sqlitePlannerStrategies = [nullabilityTighteningBackfillStrategy, recreateTableStrategy];
-//#endregion
-//#region src/core/migrations/issue-planner.ts
-const ISSUE_KIND_ORDER = {
-	extra_foreign_key: 10,
-	extra_unique_constraint: 11,
-	extra_primary_key: 12,
-	extra_index: 13,
-	extra_default: 14,
-	extra_column: 15,
-	extra_table: 16,
-	missing_table: 20,
-	missing_column: 30,
-	type_mismatch: 40,
-	nullability_mismatch: 41,
-	default_missing: 42,
-	default_mismatch: 43,
-	primary_key_mismatch: 50,
-	unique_constraint_mismatch: 51,
-	index_mismatch: 52,
-	foreign_key_mismatch: 60
-};
-function issueOrder(issue) {
-	return ISSUE_KIND_ORDER[issue.kind] ?? 99;
-}
-function issueKey(issue) {
-	return `${"table" in issue && typeof issue.table === "string" ? issue.table : ""}\u0000${"column" in issue && typeof issue.column === "string" ? issue.column : ""}\u0000${"indexOrConstraint" in issue && typeof issue.indexOrConstraint === "string" ? issue.indexOrConstraint : ""}`;
-}
-function issueConflict(kind, summary, location) {
-	return {
-		kind,
-		summary,
-		why: "Use `migration new` to author a custom migration for this change.",
-		...location ? { location } : {}
-	};
-}
-function conflictKindForIssue(issue) {
-	switch (issue.kind) {
-		case "type_mismatch": return "typeMismatch";
-		case "nullability_mismatch": return "nullabilityConflict";
-		case "primary_key_mismatch":
-		case "unique_constraint_mismatch":
-		case "index_mismatch":
-		case "extra_primary_key":
-		case "extra_unique_constraint": return "indexIncompatible";
-		case "foreign_key_mismatch":
-		case "extra_foreign_key": return "foreignKeyConflict";
-		default: return "missingButNonAdditive";
-	}
-}
-function issueLocation(issue) {
-	if (issue.kind === "enum_values_changed") return void 0;
-	const location = {};
-	if (issue.table) location.table = issue.table;
-	if (issue.column) location.column = issue.column;
-	if (issue.indexOrConstraint) location.constraint = issue.indexOrConstraint;
-	return Object.keys(location).length > 0 ? location : void 0;
-}
-function conflictForDisallowedCall(call, allowed) {
-	const summary = `Operation "${call.label}" requires class "${call.operationClass}", but policy allows only: ${allowed.join(", ")}`;
-	const location = locationForCall(call);
-	return {
-		kind: conflictKindForCall(call),
-		summary,
-		why: "Use `migration new` to author a custom migration for this change.",
-		...location ? { location } : {}
-	};
-}
-function conflictKindForCall(call) {
-	switch (call.factoryName) {
-		case "createIndex":
-		case "dropIndex": return "indexIncompatible";
-		default: return "missingButNonAdditive";
-	}
-}
-function locationForCall(call) {
-	const location = {};
-	if ("tableName" in call) location.table = call.tableName;
-	if ("columnName" in call) location.column = call.columnName;
-	if ("indexName" in call) location.index = call.indexName;
-	return Object.keys(location).length > 0 ? location : void 0;
-}
-function isMissing(issue) {
-	if (issue.kind === "enum_values_changed") return false;
-	return issue.actual === void 0;
-}
-/**
-* Resolves codec / `typeRef` / default rendering into a flat
-* `SqliteColumnSpec`. Mirrors Postgres's `toColumnSpec`. Once a column is
-* flattened, downstream Calls and operation factories never see
-* `StorageColumn` again — they deal in pre-rendered SQL fragments.
-*/
-function toColumnSpec(name, column, storageTypes, inlineAutoincrementPrimaryKey = false) {
-	return {
-		name,
-		typeSql: buildColumnTypeSql(column, blindCast(storageTypes)),
-		defaultSql: buildColumnDefaultSql(column.default),
-		nullable: column.nullable,
-		...inlineAutoincrementPrimaryKey ? { inlineAutoincrementPrimaryKey: true } : {}
-	};
-}
-/**
-* Flattens a `StorageTable` into a `SqliteTableSpec` ready for
-* `CreateTableCall` / `RecreateTableCall`. Sole-column AUTOINCREMENT
-* primary keys are detected here and marked on the column spec so the
-* renderer emits `INTEGER PRIMARY KEY AUTOINCREMENT` inline.
-*/
-function toTableSpec(table, storageTypes) {
-	const columns = Object.entries(table.columns).map(([name, column]) => toColumnSpec(name, column, storageTypes, isInlineAutoincrementPrimaryKey(table, name)));
-	const uniques = table.uniques.map((u) => ({
-		columns: u.columns,
-		...u.name !== void 0 ? { name: u.name } : {}
-	}));
-	const foreignKeys = table.foreignKeys.map((fk) => ({
-		columns: fk.source.columns,
-		references: {
-			table: fk.target.tableName,
-			columns: fk.target.columns
-		},
-		constraint: fk.constraint !== false,
-		...fk.name !== void 0 ? { name: fk.name } : {},
-		...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
-		...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
-	}));
-	return {
-		columns,
-		...table.primaryKey ? { primaryKey: { columns: table.primaryKey.columns } } : {},
-		uniques,
-		foreignKeys
-	};
-}
-function sqliteDefaultToDdlColumnDefault(columnDefault) {
-	if (!columnDefault) return void 0;
-	switch (columnDefault.kind) {
-		case "literal": return new LiteralColumnDefault(columnDefault.value);
-		case "function":
-			if (columnDefault.expression === "autoincrement()") return void 0;
-			return new FunctionColumnDefault(columnDefault.expression);
-		default: throw new Error(`sqliteDefaultToDdlColumnDefault: unhandled kind "${blindCast(columnDefault).kind}"`);
-	}
-}
-/**
-* Converts a `StorageTable` to the `DdlColumn[]` + `DdlTableConstraint[]`
-* pair used by `CreateTableCall`. This is the structured form consumed by
-* the DDL lowering path; `toTableSpec` / `toColumnSpec` remain in use for
-* `RecreateTableCall` and `AddColumnCall` (Phase 2).
-*/
-function tableToDdlParts(table, storageTypes) {
-	const columns = Object.entries(table.columns).map(([name, column]) => {
-		const inlineAutoincrement = isInlineAutoincrementPrimaryKey(table, name);
-		const typeSql = buildColumnTypeSql(column, blindCast(storageTypes));
-		if (inlineAutoincrement) return new DdlColumn({
-			name,
-			type: `${typeSql} PRIMARY KEY AUTOINCREMENT`
-		});
-		const colDefault = sqliteDefaultToDdlColumnDefault(column.default);
-		const resolved = resolveColumnTypeMetadata(column, blindCast(storageTypes));
-		const codecRef = resolved.codecId ? {
-			codecId: resolved.codecId,
-			...resolved.typeParams !== void 0 ? { typeParams: blindCast(resolved.typeParams) } : {}
-		} : void 0;
-		return new DdlColumn({
-			name,
-			type: typeSql,
-			...!column.nullable ? { notNull: true } : {},
-			...colDefault !== void 0 ? { default: colDefault } : {},
-			...codecRef !== void 0 ? { codecRef } : {}
-		});
-	});
-	const constraints = [];
-	const hasInlinePk = Object.entries(table.columns).some(([name]) => isInlineAutoincrementPrimaryKey(table, name));
-	if (table.primaryKey && !hasInlinePk) constraints.push(new PrimaryKeyConstraint({ columns: table.primaryKey.columns }));
-	for (const u of table.uniques) constraints.push(new UniqueConstraint({
-		columns: u.columns,
-		...u.name !== void 0 ? { name: u.name } : {}
-	}));
-	for (const fk of table.foreignKeys) {
-		if (fk.constraint === false) continue;
-		constraints.push(new ForeignKeyConstraint({
-			columns: fk.source.columns,
-			refTable: fk.target.tableName,
-			refColumns: fk.target.columns,
-			...ifDefined("name", fk.name),
-			...ifDefined("onDelete", fk.onDelete),
-			...ifDefined("onUpdate", fk.onUpdate)
-		}));
-	}
-	return {
-		columns,
-		constraints
-	};
-}
-const DEFAULT_POLICY = { allowedOperationClasses: [
-	"additive",
-	"widening",
-	"destructive",
-	"data"
-] };
-function emptySchemaIR() {
-	return { tables: {} };
-}
-function mapIssueToCall(issue, ctx) {
-	switch (issue.kind) {
-		case "missing_table": {
-			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Missing table issue has no table name"));
-			const namespaceId = resolveNamespaceIdForIssue(issue);
-			const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);
-			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" in namespace "${namespaceId}" reported missing but not found in destination contract`));
-			const { columns: ddlColumns, constraints: ddlConstraints } = tableToDdlParts(contractTable, ctx.storageTypes);
-			const calls = [new CreateTableCall(issue.table, ddlColumns, ddlConstraints.length > 0 ? ddlConstraints : void 0)];
-			const declaredIndexColumnKeys = /* @__PURE__ */ new Set();
-			for (const index of contractTable.indexes) {
-				const indexName = index.name ?? defaultIndexName(issue.table, index.columns);
-				declaredIndexColumnKeys.add(index.columns.join(","));
-				calls.push(new CreateIndexCall(issue.table, indexName, index.columns));
-			}
-			for (const fk of contractTable.foreignKeys) {
-				if (fk.index === false) continue;
-				if (declaredIndexColumnKeys.has(fk.source.columns.join(","))) continue;
-				const indexName = defaultIndexName(issue.table, fk.source.columns);
-				calls.push(new CreateIndexCall(issue.table, indexName, fk.source.columns));
-			}
-			return ok(calls);
-		}
-		case "missing_column": {
-			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Missing column issue has no table/column name"));
-			const namespaceId = resolveNamespaceIdForIssue(issue);
-			const contractTable2 = tableAt(ctx.toContract.storage, namespaceId, issue.table);
-			const column = contractTable2?.columns[issue.column];
-			if (!column) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" not in destination contract`));
-			const contractTable = contractTable2;
-			const columnSpec = toColumnSpec(issue.column, column, ctx.storageTypes, contractTable ? isInlineAutoincrementPrimaryKey(contractTable, issue.column) : false);
-			return ok([new AddColumnCall(issue.table, columnSpec)]);
-		}
-		case "index_mismatch": {
-			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Index issue has no table name"));
-			if (!isMissing(issue) || !issue.expected) return notOk(issueConflict("indexIncompatible", `Index on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
-			const namespaceId = resolveNamespaceIdForIssue(issue);
-			const columns = issue.expected.split(", ");
-			const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);
-			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" not found in destination contract`));
-			const indexName = contractTable.indexes.find((idx) => idx.columns.join(",") === columns.join(","))?.name ?? defaultIndexName(issue.table, columns);
-			return ok([new CreateIndexCall(issue.table, indexName, columns)]);
-		}
-		case "extra_table":
-			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra table issue has no table name"));
-			if (CONTROL_TABLE_NAMES.has(issue.table)) return ok([]);
-			return ok([new DropTableCall(issue.table)]);
-		case "extra_column":
-			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra column issue has no table/column name"));
-			return ok([new DropColumnCall(issue.table, issue.column)]);
-		case "extra_index":
-			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Extra index issue has no table/index name"));
-			return ok([new DropIndexCall(issue.table, issue.indexOrConstraint)]);
-		case "enum_values_changed": return notOk(issueConflict("unsupportedOperation", "Received enum_values_changed against a SQLite schema (sql.enums: false) — verifier bug"));
-		case "type_mismatch":
-		case "nullability_mismatch":
-		case "default_mismatch":
-		case "default_missing":
-		case "extra_default":
-		case "primary_key_mismatch":
-		case "unique_constraint_mismatch":
-		case "foreign_key_mismatch":
-		case "extra_foreign_key":
-		case "extra_unique_constraint":
-		case "extra_primary_key": return notOk(issueConflict(conflictKindForIssue(issue), issue.message, issueLocation(issue)));
-		default: return notOk(issueConflict("unsupportedOperation", `Unhandled issue kind: ${issue.kind}`));
-	}
-}
-function classifyCall(call) {
-	switch (call.factoryName) {
-		case "createTable": return "create-table";
-		case "addColumn": return "add-column";
-		case "createIndex": return "create-index";
-		case "dropColumn": return "drop-column";
-		case "dropIndex": return "drop-index";
-		case "dropTable": return "drop-table";
-		case "recreateTable": return null;
-		default: return null;
-	}
-}
-function planIssues(options) {
-	const policyProvided = options.policy !== void 0;
-	const policy = options.policy ?? DEFAULT_POLICY;
-	const schema = options.schema ?? emptySchemaIR();
-	const frameworkComponents = options.frameworkComponents ?? [];
-	const context = {
-		toContract: options.toContract,
-		fromContract: options.fromContract,
-		codecHooks: options.codecHooks,
-		storageTypes: options.storageTypes,
-		schema,
-		policy,
-		frameworkComponents
-	};
-	const strategies = options.strategies ?? sqlitePlannerStrategies;
-	let remaining = options.issues;
-	const recipeCalls = [];
-	const bucketableCalls = [];
-	for (const strategy of strategies) {
-		const result = strategy(remaining, context);
-		if (result.kind === "match") {
-			remaining = result.issues;
-			if (result.recipe) recipeCalls.push(...result.calls);
-			else bucketableCalls.push(...result.calls);
-		}
-	}
-	const sorted = [...remaining].sort((a, b) => {
-		const kindDelta = issueOrder(a) - issueOrder(b);
-		if (kindDelta !== 0) return kindDelta;
-		const keyA = issueKey(a);
-		const keyB = issueKey(b);
-		return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
-	});
-	const defaultCalls = [];
-	const conflicts = [];
-	for (const issue of sorted) {
-		const result = mapIssueToCall(issue, context);
-		if (result.ok) defaultCalls.push(...result.value);
-		else conflicts.push(result.failure);
-	}
-	const allowed = policy.allowedOperationClasses;
-	let gatedRecipe = recipeCalls;
-	let gatedBucketable = bucketableCalls;
-	let gatedDefault = defaultCalls;
-	if (policyProvided) {
-		const sink = (acc) => (call) => {
-			if (allowed.includes(call.operationClass)) {
-				acc.push(call);
-				return;
-			}
-			conflicts.push(conflictForDisallowedCall(call, allowed));
-		};
-		const gatedRecipeBucket = [];
-		const gatedBucketableBucket = [];
-		const gatedDefaultBucket = [];
-		recipeCalls.forEach(sink(gatedRecipeBucket));
-		bucketableCalls.forEach(sink(gatedBucketableBucket));
-		defaultCalls.forEach(sink(gatedDefaultBucket));
-		gatedRecipe = gatedRecipeBucket;
-		gatedBucketable = gatedBucketableBucket;
-		gatedDefault = gatedDefaultBucket;
-	}
-	if (conflicts.length > 0) return notOk(conflicts);
-	const combined = [...gatedDefault, ...gatedBucketable];
-	const byCategory = (cat) => combined.filter((c) => classifyCall(c) === cat);
-	return ok({ calls: [
-		...byCategory("create-table"),
-		...byCategory("add-column"),
-		...byCategory("create-index"),
-		...gatedRecipe,
-		...byCategory("drop-column"),
-		...byCategory("drop-index"),
-		...byCategory("drop-table")
-	] });
-}
-//#endregion
-//#region src/core/migrations/planner.ts
-function createSqliteMigrationPlanner(lowerer) {
-	return new SqliteMigrationPlanner(lowerer);
-}
-/**
-* SQLite migration planner — a thin wrapper over `planIssues`.
-*
-* `plan()` verifies the live schema against the target contract (producing
-* `SchemaIssue[]`) and delegates to `planIssues` with the registered
-* strategies. Strategies absorb groups of related issues into composite
-* recipes (e.g. recreating a table to apply type/nullability/default/
-* constraint changes at once); anything not absorbed by a strategy flows
-* through `mapIssueToCall` in the issue planner as a one-off call.
-*
-* FK-backing indexes are surfaced by `verifySqlSchema`'s index expansion
-* (see `verify-sql-schema.ts:459-469`), so `mapIssueToCall` handles them
-* uniformly alongside user-declared indexes.
-*/
-var SqliteMigrationPlanner = class {
-	#lowerer;
-	constructor(lowerer) {
-		this.#lowerer = lowerer;
-	}
-	plan(options) {
-		return this.planSql(options);
-	}
-	emptyMigration(context, spaceId) {
-		return new TypeScriptRenderableSqliteMigration([], {
-			from: context.fromHash,
-			to: context.toHash
-		}, spaceId, void 0, this.#lowerer);
-	}
-	planSql(options) {
-		const policyResult = this.ensureAdditivePolicy(options.policy);
-		if (policyResult) return policyResult;
-		const schemaIssues = this.collectSchemaIssues(options);
-		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
-		const storageTypes = options.contract.storage.types ?? {};
-		const result = planIssues({
-			issues: schemaIssues,
-			toContract: options.contract,
-			fromContract: options.fromContract,
-			codecHooks,
-			storageTypes,
-			schema: sqliteFlatSchema(options.schema),
-			policy: options.policy,
-			frameworkComponents: options.frameworkComponents,
-			strategies: sqlitePlannerStrategies
-		});
-		if (!result.ok) return plannerFailure(result.failure);
-		const fieldEventOps = planFieldEventOperations({
-			priorContract: options.fromContract,
-			newContract: options.contract,
-			codecHooks
-		});
-		const calls = [...result.value.calls, ...fieldEventOps];
-		const destination = {
-			storageHash: options.contract.storage.storageHash,
-			...options.contract.profileHash !== void 0 ? { profileHash: options.contract.profileHash } : {}
-		};
-		return {
-			kind: "success",
-			plan: new TypeScriptRenderableSqliteMigration(calls, {
-				from: options.fromContract?.storage.storageHash ?? null,
-				to: options.contract.storage.storageHash
-			}, options.spaceId, destination, this.#lowerer)
-		};
-	}
-	ensureAdditivePolicy(policy) {
-		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
-			kind: "unsupportedOperation",
-			summary: "Migration planner requires additive operations be allowed",
-			why: "The planner requires the \"additive\" operation class to be allowed in the policy."
-		}]);
-		return null;
-	}
-	collectSchemaIssues(options) {
-		const allowed = options.policy.allowedOperationClasses;
-		const strict = allowed.includes("widening") || allowed.includes("destructive");
-		const rawDiff = diffSqliteDatabaseSchema({
-			contract: options.contract,
-			actualSchema: options.schema,
-			strict,
-			typeMetadataRegistry: /* @__PURE__ */ new Map(),
-			frameworkComponents: options.frameworkComponents
-		});
-		return (options.keepDiffIssue ? rawDiff.filter(options.keepDiffIssue) : rawDiff).issues;
-	}
-};
-/**
-* SQLite has a single, flat schema — its introspected node IS a per-schema
-* `SqlSchemaIR`, never the multi-namespace tree the Postgres target builds. The
-* planner consumes that flat shape directly when building ops.
-*/
-function sqliteFlatSchema(schema) {
-	return blindCast(schema);
-}
-//#endregion
-export { verifySqliteDatabaseSchema as a, sqliteContractToSchema as i, createSqliteMigrationPlanner as n, diffSqliteDatabaseSchema as r, SqliteMigrationPlanner as t };
-
-//# sourceMappingURL=planner-EoQcJGzv.mjs.map