@prisma-next/target-sqlite 0.14.0-dev.6 → 0.14.0-dev.60

package/dist/planner-DGhzXuGh.mjs

@@ -0,0 +1,848 @@
+import { a as DropColumnCall, d as buildRecreateSummary, h as renderDefaultLiteral, 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-Do03QgD9.mjs";
+import { t as CONTROL_TABLE_NAMES } from "./control-tables-7KwMyJ6i.mjs";
+import { t as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-BDzhFAoW.mjs";
+import { DdlColumn, ForeignKeyConstraint, FunctionColumnDefault, LiteralColumnDefault, PrimaryKeyConstraint, UniqueConstraint } from "@prisma-next/sql-relational-core/ast";
+import { RelationalSchemaNodeKind, SqlSchemaIR, relationalNodeGranularity } from "@prisma-next/sql-schema-ir/types";
+import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma-next/framework-components/ir";
+import { buildNativeTypeExpander, contractToSchemaIR, extractCodecControlHooks, planFieldEventOperations, plannerFailure } from "@prisma-next/family-sql/control";
+import { verifySqlSchemaByDiff } from "@prisma-next/family-sql/diff";
+import { diffSchemas } from "@prisma-next/framework-components/control";
+import { blindCast } from "@prisma-next/utils/casts";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
+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.
+*
+* `extras` thread the plan-time derivation input: the native-type expander,
+* so the expected side carries resolved native types (like the verify
+* side). Every expected column also carries its `codecRef` unconditionally
+* (Decision 5) — the planner's op-builders resolve DDL rendering from it at
+* plan time, so no separate render stamper is threaded here.
+*/
+function sqliteContractToSchema(contract, extras) {
+	return contractToSchemaIR(contract, {
+		annotationNamespace: "sqlite",
+		renderDefault: sqliteRenderDefault,
+		...ifDefined("expandNativeType", extras?.expandNativeType)
+	});
+}
+/**
+* The SQLite schema verify: the full-tree node-diff verdict wrapped in the
+* issue-based result envelope. Used by the runner's post-apply check; the
+* family `verifySchema` runs the same composition via the descriptor hook.
+*/
+function verifySqliteDatabaseSchema(input) {
+	return verifySqlSchemaByDiff({
+		contract: input.contract,
+		schema: input.actualSchema,
+		strict: input.strict,
+		frameworkComponents: input.frameworkComponents,
+		diffSchema: diffSqliteSchema,
+		granularityOf: relationalNodeGranularity
+	});
+}
+/**
+* Resolves a verdict-diff issue's subject table's declared control policy
+* directly from the contract. SQLite's expected tree is flat, so the issue
+* path carries no namespace segment — `path[1]` is the table name (`path[0]`
+* is the tree root's own id); every contract namespace is searched for that
+* table name (table names are globally unique in the flat tree — duplicates
+* across namespaces are rejected earlier, at `contractToSchemaIR`).
+*/
+function resolveControlPolicy(issue, contract) {
+	const tableName = issue.path[1];
+	if (tableName === void 0) return void 0;
+	for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+		const table = entityAt(contract.storage, {
+			namespaceId,
+			entityKind: "table",
+			entityName: tableName
+		});
+		if (table !== void 0) return table.control;
+	}
+}
+/**
+* The SQLite full-tree node diff for the family verify verdict: derive the
+* expected flat tree with resolved leaf values (expander threaded so
+* parameterized types compare expanded; FK nodes born with the flat empty
+* `resolvedReferencedNamespace`), and run the generic differ over the trees
+* as derived. Flat targets need no ownership scoping. The codec `verifyType`
+* hooks run once per contract namespace with tables, each against the sole
+* flat actual root — exactly the legacy per-namespace pairing.
+*/
+function diffSqliteSchema(input) {
+	const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);
+	const expected = sqliteContractToSchema(input.contract, { ...ifDefined("expandNativeType", expandNativeType) });
+	const actual = input.schema instanceof SqlSchemaIR ? input.schema : blindCast(input.schema);
+	return {
+		issues: diffSchemas(expected, actual),
+		resolveControlPolicy: (issue) => resolveControlPolicy(issue, input.contract),
+		namespacePairs: Object.values(input.contract.storage.namespaces).filter((ns) => Object.keys(ns.entries.table ?? {}).length > 0).map(() => ({ actual }))
+	};
+}
+/**
+* The SQLite planner's diff input: the same tree-building
+* `diffSqliteSchema` uses (expander threaded, FK nodes born flat). One differ
+* drives both verify and plan over the trees as derived; this is the plan-side
+* derivation — column DDL resolves from each expected column's `codecRef` at
+* plan time (`column-ddl-rendering.ts`), so no separate render stamping happens here.
+*/
+function buildSqlitePlanDiff(input) {
+	const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);
+	const expected = sqliteContractToSchema(input.contract, { ...ifDefined("expandNativeType", expandNativeType) });
+	const actual = new SqlSchemaIR(withRecordKeyNames(input.actualSchema));
+	return {
+		expected,
+		actual,
+		issues: diffSchemas(expected, actual)
+	};
+}
+/**
+* Every schema-tree builder in this codebase derives a table's / column's
+* `name` from the record key it's stored under (`contractToSchemaIR`,
+* the SQLite introspection adapter) rather than trusting a redundant
+* embedded field — the record key IS the identity. Mirrors that discipline
+* for the actual/live tree before construction, so `SqlTableIR.id` /
+* `SqlColumnIR.id` (both derived from `.name`) are always correct without
+* requiring every caller to duplicate the key onto the value. A no-op for a
+* tree that already carries matching names (the real introspection adapter
+* always does).
+*/
+function withRecordKeyNames(actualSchema) {
+	const raw = blindCast(actualSchema);
+	const tables = {};
+	for (const [tableName, table] of Object.entries(raw.tables ?? {})) {
+		const rawTable = blindCast(table);
+		const columns = {};
+		for (const [columnName, column] of Object.entries(blindCast(table).columns ?? {})) columns[columnName] = {
+			...blindCast(column),
+			name: columnName
+		};
+		tables[tableName] = {
+			...rawTable,
+			name: tableName,
+			columns,
+			foreignKeys: rawTable.foreignKeys ?? [],
+			uniques: rawTable.uniques ?? [],
+			indexes: rawTable.indexes ?? []
+		};
+	}
+	return { tables };
+}
+//#endregion
+//#region src/core/migrations/column-ddl-rendering.ts
+/**
+* Reconstructs the `StorageColumn`-shaped fields `buildColumnTypeSql` /
+* `buildColumnDefaultSql` expect, from a column node's own stamped codec
+* identity (`codecRef` / `codecBaseNativeType`, Decision 5) — never the
+* contract. SQLite's type renderer only uppercases the resolved base type
+* (no parameterized expansion, no named-type quoting), so `typeRef` is
+* deliberately left unset here: setting it would send `buildColumnTypeSql`
+* back through a live `storageTypes` lookup the node's fields have already
+* resolved past, which throws for an unrecognized reference (unlike
+* Postgres's lenient fallback).
+*/
+function columnLike(column) {
+	if (column.codecRef === void 0 || column.codecBaseNativeType === void 0) throw new Error(`columnLike: expected column "${column.name}" carries no codec identity — the expected tree must be derived via contractToSchemaIR for planning`);
+	return {
+		nativeType: column.codecBaseNativeType,
+		codecId: column.codecRef.codecId,
+		nullable: column.nullable,
+		...(column.many ?? column.codecRef.many) !== void 0 ? { many: column.many ?? column.codecRef.many } : {},
+		...column.codecRef.typeParams !== void 0 ? { typeParams: blindCast(column.codecRef.typeParams) } : {},
+		...column.resolvedDefault !== void 0 ? { default: column.resolvedDefault } : {}
+	};
+}
+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}"`);
+	}
+}
+/**
+* True when the column is rendered inline as `INTEGER PRIMARY KEY
+* AUTOINCREMENT` — the sole member of the table's primary key with an
+* `autoincrement()` default. Node-based sibling of the retired
+* `isInlineAutoincrementPrimaryKey` (which read the raw `StorageTable`);
+* reads the table/column nodes instead.
+*/
+function isInlineAutoincrementPrimaryKeyNode(table, column) {
+	if (table.primaryKey?.columns.length !== 1) return false;
+	if (table.primaryKey.columns[0] !== column.name) return false;
+	return column.resolvedDefault?.kind === "function" && column.resolvedDefault.expression === "autoincrement()";
+}
+/**
+* Builds the flat `SqliteColumnSpec` `AddColumnCall` / `RecreateTableCall`
+* need, resolved from the column node's codec identity — the same builders
+* the pre-`plan(start, end)` op-path called, so the output is
+* byte-identical.
+*/
+function columnSpecFromNode(column, inline) {
+	const like = columnLike(column);
+	const typeSql = buildColumnTypeSql(like, {});
+	const defaultSql = buildColumnDefaultSql(like.default);
+	return {
+		name: column.name,
+		typeSql,
+		defaultSql,
+		nullable: column.nullable,
+		...inline ? { inlineAutoincrementPrimaryKey: true } : {}
+	};
+}
+/**
+* Builds the `DdlColumn` the `CreateTableCall` path needs, resolved from the
+* column node's codec identity.
+*/
+function ddlColumnFromNode(column, inline) {
+	const like = columnLike(column);
+	const typeSql = buildColumnTypeSql(like, {});
+	if (inline) return new DdlColumn({
+		name: column.name,
+		type: `${typeSql} PRIMARY KEY AUTOINCREMENT`
+	});
+	const colDefault = sqliteDefaultToDdlColumnDefault(like.default);
+	return new DdlColumn({
+		name: column.name,
+		type: typeSql,
+		...!column.nullable ? { notNull: true } : {},
+		...colDefault !== void 0 ? { default: colDefault } : {},
+		...column.codecRef !== void 0 ? { codecRef: column.codecRef } : {}
+	});
+}
+/**
+* Builds the table-level constraints (PK / unique / FK) for a `CreateTable`
+* path from the table node — the node-sourced sibling of the retired
+* contract-based `tableToDdlParts`'s constraint half.
+*/
+function tableConstraintsFromNode(table, hasInlinePk) {
+	const constraints = [];
+	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) constraints.push(new ForeignKeyConstraint({
+		columns: fk.columns,
+		refTable: fk.referencedTable,
+		refColumns: fk.referencedColumns,
+		...fk.name !== void 0 ? { name: fk.name } : {},
+		...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+		...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+	}));
+	return constraints;
+}
+//#endregion
+//#region src/core/migrations/planner-strategies.ts
+/**
+* Classifies a node issue into the operation class a recreate absorbing it
+* would need, or `null` when the strategy doesn't handle this node/reason at
+* all (table/column not-found-or-not-expected, and index issues — those are
+* standalone ops, never folded into a recreate).
+*
+* Column drift is a single `not-equal` issue now (type AND nullability
+* compared together by `SqlColumnIR.isEqualTo`), so this reads both fields
+* off the node pair directly rather than trusting a separate issue kind per
+* attribute: a type change is always destructive; a pure nullability change
+* is destructive when tightening (NOT NULL required) and widening when
+* relaxing.
+*/
+function classifyNodeIssue(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return null;
+	switch (blindCast(node).nodeKind) {
+		case RelationalSchemaNodeKind.column: {
+			if (issue.reason !== "not-equal") return null;
+			const expected = blindCast(issue.expected);
+			if (columnTypeChanged(expected, blindCast(issue.actual))) return "destructive";
+			return expected.nullable ? "widening" : "destructive";
+		}
+		case RelationalSchemaNodeKind.columnDefault: return issue.reason === "not-expected" ? "destructive" : "widening";
+		case RelationalSchemaNodeKind.primaryKey:
+		case RelationalSchemaNodeKind.foreignKey:
+		case RelationalSchemaNodeKind.unique: return "destructive";
+		default: 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 `mapNodeIssueToCall` doesn't double-handle them.
+*
+* The full desired/live table shapes come from `ctx.expected`/`ctx.actual`
+* directly (keyed by table name — SQLite is a flat, single-namespace target)
+* rather than from any individual issue, since a single drifted attribute's
+* issue only carries that attribute's own node, never the whole table.
+*/
+const recreateTableStrategy = (issues, ctx) => {
+	const byTable = /* @__PURE__ */ new Map();
+	const consumed = /* @__PURE__ */ new Set();
+	for (const issue of issues) {
+		const cls = classifyNodeIssue(issue);
+		if (!cls) continue;
+		const tableName = issue.path[1];
+		if (tableName === void 0) continue;
+		const entry = byTable.get(tableName);
+		if (entry) {
+			entry.issues.push(issue);
+			if (cls === "destructive") entry.hasDestructive = true;
+		} else byTable.set(tableName, {
+			issues: [issue],
+			hasDestructive: cls === "destructive"
+		});
+		consumed.add(issue);
+	}
+	if (byTable.size === 0) return { kind: "no_match" };
+	const calls = [];
+	for (const [tableName, entry] of byTable) {
+		const expectedTable = ctx.expected.tables[tableName];
+		const actualTable = ctx.actual.tables[tableName];
+		if (!expectedTable || !actualTable) continue;
+		const operationClass = entry.hasDestructive ? "destructive" : "widening";
+		const tableSpec = tableSpecFromNode(expectedTable);
+		const indexes = expectedTable.indexes.map((idx) => ({
+			name: idx.name ?? defaultIndexName(tableName, idx.columns),
+			columns: idx.columns
+		}));
+		calls.push(new RecreateTableCall({
+			tableName,
+			contractTable: tableSpec,
+			schemaColumnNames: Object.keys(actualTable.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 expected tree 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.reason !== "not-equal" || issue.expected === void 0 || issue.actual === void 0) continue;
+		if (blindCast(issue.expected).nodeKind !== RelationalSchemaNodeKind.column) continue;
+		const expectedColumn = blindCast(issue.expected);
+		const actualColumn = blindCast(issue.actual);
+		if (expectedColumn.nullable === actualColumn.nullable) continue;
+		if (expectedColumn.nullable) continue;
+		const tableName = issue.path[1];
+		if (tableName === void 0) continue;
+		calls.push(new DataTransformCall(`data_migration.backfill-${tableName}-${expectedColumn.name}`, `Backfill NULLs in "${tableName}"."${expectedColumn.name}" before NOT NULL tightening`, tableName, expectedColumn.name));
+	}
+	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
+/**
+* Re-keys the legacy `ISSUE_KIND_ORDER` (kind string → priority number) on
+* `(nodeKind, reason)`. Numbers are preserved from the legacy table so the
+* dependency intent stays legible; the final emission order is actually
+* fixed downstream by category bucketing (create-table → add-column →
+* create-index → recreate → drop-column → drop-index → drop-table), so this
+* only breaks ties within a single bucket.
+*/
+function nodeIssueOrder(issue) {
+	const node = issueNode(issue);
+	if (node === void 0) return 99;
+	switch (node.nodeKind) {
+		case RelationalSchemaNodeKind.foreignKey: return issue.reason === "not-expected" ? 10 : 60;
+		case RelationalSchemaNodeKind.unique: return issue.reason === "not-expected" ? 11 : 51;
+		case RelationalSchemaNodeKind.primaryKey: return issue.reason === "not-expected" ? 12 : 50;
+		case RelationalSchemaNodeKind.index: return issue.reason === "not-expected" ? 13 : 52;
+		case RelationalSchemaNodeKind.columnDefault:
+			if (issue.reason === "not-expected") return 14;
+			return issue.reason === "not-found" ? 42 : 43;
+		case RelationalSchemaNodeKind.column:
+			if (issue.reason === "not-expected") return 15;
+			return issue.reason === "not-found" ? 30 : 40;
+		case RelationalSchemaNodeKind.table: return issue.reason === "not-expected" ? 16 : 20;
+		case RelationalSchemaNodeKind.check:
+			if (issue.reason === "not-found") return 53;
+			return issue.reason === "not-expected" ? 54 : 55;
+		default: return 99;
+	}
+}
+/** Deterministic tiebreak within an order bucket: the diff path itself already encodes table → child → grandchild. */
+function nodeIssueKey(issue) {
+	return issue.path.join(" ");
+}
+/**
+* The generic differ is total: a missing/extra table (or column) emits an
+* issue for itself AND for every node in its subtree (columns, defaults,
+* constraints, indexes). `CreateTableCall`/`DropTableCall` and
+* `AddColumnCall`/`DropColumnCall` already account for the whole subtree
+* (reading it directly off the table/column node), so the nested issues are
+* redundant — coalescing them is "the planner's responsibility" the differ's
+* own contract assigns (`schema-diff.ts`). Drops any issue whose path is a
+* strict descendant of a `not-found`/`not-expected` issue's path.
+*/
+function coalesceSubtreeIssues(issues) {
+	const collapsingPaths = issues.filter((issue) => issue.reason === "not-found" || issue.reason === "not-expected").map((issue) => issue.path);
+	if (collapsingPaths.length === 0) return issues;
+	return issues.filter((issue) => !collapsingPaths.some((ancestor) => isStrictDescendantPath(issue.path, ancestor)));
+}
+function isStrictDescendantPath(path, ancestor) {
+	if (path.length <= ancestor.length) return false;
+	for (let i = 0; i < ancestor.length; i += 1) if (path[i] !== ancestor[i]) return false;
+	return true;
+}
+function issueNode(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return void 0;
+	return blindCast(node);
+}
+/** Whether the expected/actual native type (resolved, or raw+many fallback) differs — mirrors `SqlColumnIR.isEqualTo`'s type comparison. */
+function columnTypeChanged(expected, actual) {
+	if (expected.resolvedNativeType !== void 0 && actual.resolvedNativeType !== void 0) return expected.resolvedNativeType !== actual.resolvedNativeType;
+	return expected.nativeType !== actual.nativeType || Boolean(expected.many) !== Boolean(actual.many);
+}
+/**
+* Builds the flat `SqliteTableSpec` `RecreateTableCall` needs from the
+* expected table node — the node-sourced equivalent of the retired
+* `toTableSpec` (which read a raw contract `StorageTable`). Every column's
+* spec is resolved from its `codecRef` via `columnSpecFromNode`.
+*/
+function tableSpecFromNode(table) {
+	const columns = Object.values(table.columns).map((c) => columnSpecFromNode(c, isInlineAutoincrementPrimaryKeyNode(table, c)));
+	const uniques = table.uniques.map((u) => ({
+		columns: u.columns,
+		...u.name !== void 0 ? { name: u.name } : {}
+	}));
+	const foreignKeys = table.foreignKeys.map((fk) => ({
+		columns: fk.columns,
+		references: {
+			table: fk.referencedTable,
+			columns: fk.referencedColumns
+		},
+		constraint: true,
+		...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 issueConflict(kind, summary, location) {
+	return {
+		kind,
+		summary,
+		why: "Use `migration new` to author a custom migration for this change.",
+		...location ? { location } : {}
+	};
+}
+function issueLocation(tableName, columnName) {
+	return columnName !== void 0 ? {
+		table: tableName,
+		column: columnName
+	} : { table: tableName };
+}
+/**
+* Conflict kind for a node kind that `recreateTableStrategy` absorbs for
+* every reachable production issue. Reaching `mapNodeIssueToCall` for one of
+* these means the recreate strategy didn't run — mirrors the legacy
+* `conflictKindForIssue` per-kind categorization.
+*/
+function absorbedConflictKind(nodeKind) {
+	switch (nodeKind) {
+		case RelationalSchemaNodeKind.primaryKey:
+		case RelationalSchemaNodeKind.unique: return "indexIncompatible";
+		case RelationalSchemaNodeKind.foreignKey: return "foreignKeyConflict";
+		default: return "missingButNonAdditive";
+	}
+}
+/**
+* Builds the `CreateTableCall` + per-index `CreateIndexCall`s for a
+* newly-expected table. Reads only the table node's own children — indexes
+* (declared + FK-backing, deduped) are already merged and ordered at
+* derivation (`contractToSchemaIR`'s `convertTable`).
+*/
+function buildCreateTableCalls(table) {
+	const columns = Object.values(table.columns).map((c) => ddlColumnFromNode(c, isInlineAutoincrementPrimaryKeyNode(table, c)));
+	const constraints = tableConstraintsFromNode(table, Object.values(table.columns).some((c) => isInlineAutoincrementPrimaryKeyNode(table, c)));
+	const calls = [new CreateTableCall(table.name, columns, constraints.length > 0 ? constraints : void 0)];
+	for (const index of table.indexes) {
+		const indexName = index.name ?? defaultIndexName(table.name, index.columns);
+		calls.push(new CreateIndexCall(table.name, indexName, index.columns));
+	}
+	return calls;
+}
+function mapTableIssue(issue) {
+	if (issue.reason === "not-found") return ok(buildCreateTableCalls(blindCast(issue.expected)));
+	if (issue.reason === "not-expected") {
+		const table = blindCast(issue.actual);
+		if (CONTROL_TABLE_NAMES.has(table.name)) return ok([]);
+		return ok([new DropTableCall(table.name)]);
+	}
+	return notOk(issueConflict("unsupportedOperation", `Unexpected table drift: ${issue.path.join("/")}`));
+}
+function mapColumnIssue(issue, ctx) {
+	const tableName = issue.path[1];
+	if (tableName === void 0) return notOk(issueConflict("unsupportedOperation", `Column issue has no table in its path: ${issue.path.join("/")}`));
+	if (issue.reason === "not-found") {
+		const column = blindCast(issue.expected);
+		const table = ctx.expected.tables[tableName];
+		return ok([new AddColumnCall(tableName, columnSpecFromNode(column, table !== void 0 && isInlineAutoincrementPrimaryKeyNode(table, column)))]);
+	}
+	if (issue.reason === "not-expected") return ok([new DropColumnCall(tableName, blindCast(issue.actual).name)]);
+	const expected = blindCast(issue.expected);
+	return notOk(issueConflict(columnTypeChanged(expected, blindCast(issue.actual)) ? "typeMismatch" : "nullabilityConflict", issue.path.join("/"), issueLocation(tableName, expected.name)));
+}
+function mapIndexIssue(issue) {
+	const tableName = issue.path[1];
+	if (tableName === void 0) return notOk(issueConflict("unsupportedOperation", `Index issue has no table in its path: ${issue.path.join("/")}`));
+	if (issue.reason === "not-found") {
+		const index = blindCast(issue.expected);
+		return ok([new CreateIndexCall(tableName, index.name ?? defaultIndexName(tableName, index.columns), index.columns)]);
+	}
+	if (issue.reason === "not-expected") {
+		const index = blindCast(issue.actual);
+		return ok([new DropIndexCall(tableName, index.name ?? defaultIndexName(tableName, index.columns))]);
+	}
+	return notOk(issueConflict("indexIncompatible", issue.path.join("/"), issueLocation(tableName)));
+}
+function mapNodeIssueToCall(issue, ctx) {
+	const node = issueNode(issue);
+	if (node === void 0) return notOk(issueConflict("unsupportedOperation", `Issue carries neither an expected nor an actual node: ${issue.path.join("/")}`));
+	switch (node.nodeKind) {
+		case RelationalSchemaNodeKind.table: return mapTableIssue(issue);
+		case RelationalSchemaNodeKind.column: return mapColumnIssue(issue, ctx);
+		case RelationalSchemaNodeKind.index: return mapIndexIssue(issue);
+		case RelationalSchemaNodeKind.columnDefault:
+		case RelationalSchemaNodeKind.primaryKey:
+		case RelationalSchemaNodeKind.foreignKey:
+		case RelationalSchemaNodeKind.unique: return notOk(issueConflict(absorbedConflictKind(node.nodeKind), issue.path.join("/")));
+		case RelationalSchemaNodeKind.check: return notOk(issueConflict("unsupportedOperation", `SQLite does not support CHECK constraint DDL: ${issue.path.join("/")}`));
+		default: return notOk(issueConflict("unsupportedOperation", `Unhandled node kind: ${node.nodeKind}`));
+	}
+}
+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;
+	}
+}
+const DEFAULT_POLICY = { allowedOperationClasses: [
+	"additive",
+	"widening",
+	"destructive",
+	"data"
+] };
+function planIssues(options) {
+	const policyProvided = options.policy !== void 0;
+	const policy = options.policy ?? DEFAULT_POLICY;
+	const frameworkComponents = options.frameworkComponents ?? [];
+	const context = {
+		expected: options.expected ?? emptySchemaIR(),
+		actual: options.actual ?? emptySchemaIR(),
+		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 = nodeIssueOrder(a) - nodeIssueOrder(b);
+		if (kindDelta !== 0) return kindDelta;
+		const keyA = nodeIssueKey(a);
+		const keyB = nodeIssueKey(b);
+		return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+	});
+	const defaultCalls = [];
+	const conflicts = [];
+	for (const issue of sorted) {
+		const result = mapNodeIssueToCall(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")
+	] });
+}
+function emptySchemaIR() {
+	return new SqlSchemaIR({ tables: {} });
+}
+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;
+}
+//#endregion
+//#region src/core/migrations/planner.ts
+function createSqliteMigrationPlanner(lowerer) {
+	return new SqliteMigrationPlanner(lowerer);
+}
+/**
+* SQLite migration planner — a thin wrapper over `planIssues`.
+*
+* `plan()` diffs the live schema against the target contract via the one
+* differ (`buildSqlitePlanDiff`, producing node-typed `SchemaDiffIssue[]`)
+* 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 `mapNodeIssueToCall` in
+* the issue planner as a one-off call.
+*
+* FK-backing indexes are already merged into the expected table node's
+* `indexes` at derivation (`contractToSchemaIR`'s `convertTable`), so
+* `mapNodeIssueToCall` handles them uniformly alongside user-declared
+* indexes — no separate expansion step in the planner.
+*/
+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 { expected, actual, issues } = this.collectSchemaIssues(options);
+		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+		const result = planIssues({
+			issues,
+			expected,
+			actual,
+			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;
+	}
+	/**
+	* Diffs the target contract against the live schema via the one differ
+	* (the same tree-building `diffSqliteSchema` uses, plus the
+	* op-render stamper) and prepares the issue list `planIssues` consumes.
+	*
+	* Three passes, in order:
+	* 1. Subtree coalescing — the differ is total (a missing/extra table also
+	*    emits an issue for every column/constraint under it); those nested
+	*    issues are redundant once the table-level `CreateTable`/`DropTable`
+	*    call already accounts for the whole subtree. Runs FIRST, over the
+	*    complete diff: a sibling-owned extra table's column issues must
+	*    collapse into its one table-level issue before the ownership pass,
+	*    because a bare column node carries no table reference — if coalescing
+	*    ran after ownership dropped the table-level issue, the orphaned column
+	*    issues would survive and the planner would emit drops against a
+	*    sibling space's table.
+	* 2. Ownership — a live extra is only this plan's to drop when no contract
+	*    space owns it. The differ ran against THIS space's contract, so a
+	*    table a sibling owns surfaces here as `not-expected`; the planner asks
+	*    the ownership oracle (the passive aggregate) whether any space declares
+	*    it and, if so, leaves it alone. A table no space owns stays a genuine
+	*    extra. Ownership lives in the aggregate; the planner only asks. No
+	*    oracle (single-space) keeps every extra.
+	* 3. Strict-mode extras gating — `not-expected` (extra table/column/
+	*    constraint) issues are dropped entirely outside strict mode, mirroring
+	*    the retired coordinate walk's `if (strict) { ...extra_* } }` guards:
+	*    an additive-only plan must never even consider dropping an unclaimed
+	*    object, not just refuse to emit the drop.
+	*/
+	collectSchemaIssues(options) {
+		const allowed = options.policy.allowedOperationClasses;
+		const strict = allowed.includes("widening") || allowed.includes("destructive");
+		const { expected, actual, issues: rawIssues } = buildSqlitePlanDiff({
+			contract: options.contract,
+			actualSchema: options.schema,
+			frameworkComponents: options.frameworkComponents
+		});
+		const owned = retainUnownedExtras(coalesceSubtreeIssues(rawIssues), options.ownership);
+		return {
+			expected,
+			actual,
+			issues: strict ? owned : owned.filter((issue) => issue.reason !== "not-expected")
+		};
+	}
+};
+/**
+* Drops a `not-expected` issue when it is a whole extra TABLE that some
+* contract space owns, asking the ownership oracle per node.
+*
+* The consultation applies ONLY to table-level extras — a live table this
+* space's contract lacks — identified by asking the issue's own node
+* (`nodeKind === table`), never by counting path segments. SQLite is a
+* single-namespace target, so every coordinate is qualified with the shared
+* `UNBOUND_NAMESPACE_ID` sentinel (the same one the aggregate's declared
+* entities carry for this target). `entityKind` is the literal `'table'`:
+* this function only ever asks about a node already confirmed to be
+* `RelationalSchemaNodeKind.table` (checked just above), and that's a
+* diff-tree `nodeKind` spelling (`'sql-table'`) distinct from the storage
+* `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal
+* is that storage-entries spelling. `declaresEntity` answers over the whole
+* composition (self included), so a positive answer on such a table means
+* another space owns it (a table this space owned would be in its expected
+* tree, never an extra): leave it. A negative answer means no space owns
+* it — a genuine orphan to drop.
+*
+* A DEEPER extra (an extra column/constraint on a table this space DOES own —
+* only the child drifted, so the table is in the expected tree) is this
+* space's own drift and is always kept for dropping; asking the oracle there
+* would wrongly suppress it, because the owned table answers `true`. No oracle
+* ⇒ every extra is kept (single-space plan).
+*/
+function retainUnownedExtras(issues, ownership) {
+	if (ownership === void 0) return issues;
+	return issues.filter((issue) => {
+		if (issue.reason !== "not-expected") return true;
+		const node = issueNode(issue);
+		if (node === void 0 || node.nodeKind !== RelationalSchemaNodeKind.table) return true;
+		const tableName = issue.path[1];
+		return tableName === void 0 || !ownership.declaresEntity({
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			entityKind: "table",
+			entityName: tableName
+		});
+	});
+}
+//#endregion
+export { verifySqliteDatabaseSchema as a, sqliteContractToSchema as i, createSqliteMigrationPlanner as n, diffSqliteSchema as r, SqliteMigrationPlanner as t };
+
+//# sourceMappingURL=planner-DGhzXuGh.mjs.map