@prisma/orm-target-sqlite 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/pack-DR0n9vHJ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-DR0n9vHJ.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/pack.d.mts"],"mappings":"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cAAc;KAChH,aAAa;WACP;WACA,QAAQ;;WAER;WACA,QAAQ;;WAER;WACA,QAAQ;;WAER;WACA,QAAQ;;WAER;WACA,QAAQ;;WAER;;WAEA;WACA;;UAED;EACR,eAAe,MAAM,aAAa;EAClC,cAAc,MAAM,aAAa;EACjC,QAAQ,MAAM,aAAa;;;;cAIf;WACH;WACA;WACA;WACA;aACE;eACE;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;mBACE;mBACA;mBACA;qBACE;uBACE;;qBAEF;uBACE;uBACA;;;;iBAIN;mBACE;mBACA;mBACA;qBACE;uBACE;;qBAEF;uBACE;uBACA;;qBAEF;uBACE;uBACA;;;;;eAKR;iBACE;mBACE;mBACA;mBACA;qBACE;qBACA;qBACA;;mBAEF;qBACE;qBACA;uBACE;yBACE;yBACA;;;;;;eAMV;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;iBACA;iBACA;mBACE;;;eAGJ;iBACE;iBACA;iBACA;mBACE;;;;aAIN;eACE;iBACE;mBACE;mBACA;qBACE;qBACA;qBACA;qBACA;;qBAEA;qBACA;qBACA;qBACA;;mBAEF,QAAQ;qBACN;;qBAEA;;qBAEA;uBACE;yBACE;yBACA;yBACA;2BACE;6BACE;6BACA;;;;uBAIN;yBACE;yBACA;yBACA;2BACE;6BACE;6BACA;;;;;;;iBAOZ;mBACE;mBACA,QAAQ;qBACN;;qBAEA;;qBAEA;uBACE;yBACE;yBACA;;;;;iBAKR;mBACE;mBACA,QAAQ;qBACN;;qBAEA;;qBAEA;uBACE;yBACE;yBACA;;uBAEF;yBACE;yBACA;;;;;;;aAOZ,WAAW,SAAS,kEAAkE;aACtF,uEAAuE;;WAEzE;aACE;aACA,YAAY,8DAA8D;eACxE;eACA;iBACE;iBACA,MAAM,uBAAuB,cAAc,eAAe;iBAC1D;;;aAGJ;;aAEA;aACA,YAAY,8DAA8D;eACxE;eACA;iBACE;iBACA,MAAM,WAAW;iBACjB;;;aAGJ;;aAEA;aACA,YAAY,8DAA8D;eACxE;eACA;iBACE;iBACA,MAAM,wBAAwB,cAAc,gBAAgB;iBAC5D;;;aAGJ;;aAEA;aACA,wEAAwE;4DACzB;WACjD;aACE,yBAAyB;aACzB,gFAAgF;;WAElF;WACA;WACA;WACA;WACA;WACA;WACA,mEAAmE;WACnE,eAAe;;cAEZ,mCAAmC;WACtC,eAAe;WACf;aACE;eACE;eACA"}

package/dist/planner-BvwYScnt-9H9LIJFn.mjs

@@ -0,0 +1,362 @@
+import { a as DropColumnCall, l as RawSqlCall, s as DropTableCall, u as RecreateTableCall } from "./op-factory-call-emj9Xp05-BFLkxrAK.mjs";
+import { _ as sqliteSchemaTables, a as createWorkingSchema, c as issueNode, d as renameTableByHandStatements, f as renderRenameTableCall, g as sqlitePlannerStrategies, i as conflictForDisallowedCall, l as pairIndexReplacements, m as sqliteColumnRenameCall, n as buildSqlitePlanDiff, p as sqliteActualSchema, r as coalesceSubtreeIssues, s as indexNameCaseChange, u as planIssues, v as sqliteTableRenameByHand, y as sqliteTableRenameCall } from "./sqlite-migration-BAdSmooi-iWFVQgGV.mjs";
+import { t as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-D2jtaItv-ZFZhPfGE.mjs";
+import { isRenameStatement, issueOutcome } from "@prisma/orm-framework/components/control";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { appliedStatementsInOrder, backfillOfDefaultedField, columnTakesTemporaryValue, detectTableNameCaseChanges, extractCodecControlHooks, fieldEventStorage, fieldStatementColumns, planFieldEventCalls, planStatements, plannerFailure, sqlTypeLookupsOf, storageNameOfOperation, subjectsOfCalls, unknownCallNames } from "@prisma/orm-family-sql/family/control";
+import { RelationalSchemaNodeKind, SqlTableIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { ok } from "@prisma/orm-framework/utils/result";
+//#region ../../../3-targets/sqlite/1-target/dist/planner-BvwYScnt.mjs
+function lost(target, loss = "drop") {
+	return {
+		...target,
+		loss
+	};
+}
+function tableTarget(table) {
+	return {
+		storageName: table,
+		table: {
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			table,
+			column: void 0
+		}
+	};
+}
+function columnTarget(table, column) {
+	return {
+		storageName: `${table}.${column}`,
+		table: {
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			table,
+			column
+		}
+	};
+}
+function operationCountOf(call) {
+	return "companions" in call && Array.isArray(call.companions) ? 1 + call.companions.length : 1;
+}
+/**
+* The columns a recreate loses: those the new table leaves out, whose values the copy drops, and,
+* when the recreate is destructive, those whose type it changes with no copy expression to convert them.
+*/
+function recreateLosses(call) {
+	const kept = new Set(call.contractTable.columns.map((column) => column.name));
+	const dropped = call.schemaColumnNames.filter((column) => !kept.has(column));
+	const retyped = call.operationClass === "destructive" ? call.retypedColumns.filter((column) => !Object.hasOwn(call.copyExpressions, column)) : [];
+	return [...dropped.map((column) => ({
+		column,
+		loss: "drop"
+	})), ...retyped.map((column) => ({
+		column,
+		loss: "typeChange"
+	}))];
+}
+/** The columns a recreate adds with a value its copy writes into every existing row. */
+function temporaryValuesOf(call) {
+	const copied = new Set(call.schemaColumnNames);
+	return Object.entries(call.temporaryValues).flatMap(([column, expression]) => copied.has(column) || expression.kind !== "sql" ? [] : [{
+		table: call.tableName,
+		column,
+		value: expression.sql
+	}]);
+}
+/**
+* What each call of a SQLite plan loses. A recreate that leaves a column out loses its values
+* itself, so a later drop of that column is not listed again.
+*/
+function sqliteCallSubjects(calls, fieldEvents) {
+	const lostColumns = /* @__PURE__ */ new Set();
+	const unknownNames = unknownCallNames(calls.filter((call) => call.operationClass === "destructive" && !(call instanceof RecreateTableCall) && !(call instanceof DropColumnCall) && !(call instanceof DropTableCall) && !(call instanceof RawSqlCall) && !fieldEvents.has(call)));
+	return calls.map((call) => {
+		const operationCount = operationCountOf(call);
+		const { label } = call;
+		if (call instanceof RecreateTableCall) {
+			const columns = recreateLosses(call);
+			for (const { column } of columns) lostColumns.add(`${call.tableName}.${column}`);
+			return {
+				operationCount,
+				label,
+				dataLoss: columns.length === 0 && call.operationClass === "destructive" ? [lost(tableTarget(call.tableName))] : columns.map(({ column, loss }) => lost(columnTarget(call.tableName, column), loss)),
+				accessChanges: [],
+				temporaryValues: temporaryValuesOf(call)
+			};
+		}
+		if (call instanceof DropColumnCall) return {
+			operationCount,
+			label,
+			dataLoss: lostColumns.has(`${call.tableName}.${call.columnName}`) ? [] : [lost(columnTarget(call.tableName, call.columnName))],
+			accessChanges: [],
+			temporaryValues: []
+		};
+		if (call instanceof DropTableCall) return {
+			operationCount,
+			label,
+			dataLoss: [lost(tableTarget(call.tableName))],
+			accessChanges: [],
+			temporaryValues: []
+		};
+		if (call.operationClass !== "destructive") return {
+			operationCount,
+			label,
+			dataLoss: [],
+			accessChanges: [],
+			temporaryValues: []
+		};
+		const fieldEvent = fieldEvents.get(call);
+		return {
+			operationCount,
+			label,
+			dataLoss: [lost(call instanceof RawSqlCall ? {
+				storageName: storageNameOfOperation(call.op),
+				table: void 0
+			} : fieldEvent !== void 0 ? fieldEventStorage(fieldEvent) : {
+				storageName: unknownNames.get(call) ?? call.factoryName,
+				table: void 0
+			})],
+			accessChanges: [],
+			temporaryValues: []
+		};
+	});
+}
+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, context.snapshotsImportPath, void 0, this.#lowerer);
+	}
+	planSql(options) {
+		const policyResult = this.ensureAdditivePolicy(options.policy);
+		if (policyResult) return policyResult;
+		const statements = this.planStatements(options);
+		if (!statements.ok) return plannerFailure([statements.failure]);
+		const { expected, actual, issues: diffIssues } = this.collectSchemaIssues(options, statements.value.schema);
+		const replacedIndexes = pairIndexReplacements(diffIssues, indexNameCaseChange);
+		const disallowedIndexCalls = replacedIndexes.calls.filter((call) => !options.policy.allowedOperationClasses.includes(call.operationClass));
+		if (disallowedIndexCalls.length > 0) return plannerFailure(disallowedIndexCalls.map((call) => conflictForDisallowedCall(call, options.policy.allowedOperationClasses)));
+		const issues = diffIssues.filter((issue) => !replacedIndexes.consumed.has(issue));
+		const caseChangeConflicts = detectTableNameCaseChanges({
+			issues,
+			tableOf: (issue) => {
+				const node = issueNode(issue);
+				return node instanceof SqlTableIR ? node : void 0;
+			},
+			namespaceIdOf: () => UNBOUND_NAMESPACE_ID,
+			renameByHandStatements: renameTableByHandStatements,
+			renameTableCall: renderRenameTableCall,
+			contract: options.contract,
+			defaultNamespaceId: UNBOUND_NAMESPACE_ID
+		});
+		if (caseChangeConflicts.length > 0) return plannerFailure(caseChangeConflicts);
+		const defaultedBackfill = backfillOfDefaultedField(options.statements, options.fromContract, options.contract);
+		if (defaultedBackfill !== void 0) return plannerFailure([defaultedBackfill]);
+		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+		const result = planIssues({
+			issues,
+			expected,
+			actual,
+			policy: options.policy,
+			frameworkComponents: options.frameworkComponents,
+			statementColumns: fieldStatementColumns(options.statements, options.contract),
+			originCodecId: (table, column) => options.fromContract?.storage.namespaces[UNBOUND_NAMESPACE_ID]?.entries.table?.[table]?.columns[column]?.codecId,
+			takesTemporaryValue: (table, column) => {
+				const storageTable = options.contract.storage.namespaces[UNBOUND_NAMESPACE_ID]?.entries.table?.[table];
+				return storageTable !== void 0 && columnTakesTemporaryValue(storageTable, column);
+			},
+			strategies: sqlitePlannerStrategies
+		});
+		if (!result.ok) return plannerFailure(result.failure);
+		const fieldEventCalls = planFieldEventCalls({
+			priorContract: options.origin === null ? null : options.fromContract,
+			newContract: options.contract,
+			codecHooks,
+			tableRenames: statements.value.tableRenames,
+			columnRenames: statements.value.columnRenames,
+			dataTypes: sqlTypeLookupsOf(options.frameworkComponents).dataTypeLookup
+		});
+		const fieldEventOps = fieldEventCalls.map(({ call }) => call);
+		const calls = [
+			...statements.value.calls,
+			...replacedIndexes.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.origin?.storageHash ?? null,
+				to: options.contract.storage.storageHash
+			}, options.spaceId, options.snapshotsImportPath, destination, this.#lowerer),
+			appliedStatements: appliedStatementsInOrder(options.statements, statements.value.appliedStatements),
+			...subjectsOfCalls(sqliteCallSubjects(calls, new Map(fieldEventCalls.map((fieldEvent) => [fieldEvent.call, fieldEvent]))), {
+				fromContract: options.fromContract,
+				contract: options.contract,
+				origins: statements.value.origins,
+				byHand: sqliteTableRenameByHand
+			})
+		};
+	}
+	/**
+	* Plans the statements against a working copy of the schema the plan starts from, in order, so
+	* each rename's index replacements are computed against the schema the earlier statements left.
+	* The diff then runs on that schema.
+	*/
+	planStatements(options) {
+		const working = createWorkingSchema(sqliteActualSchema(options.schema));
+		const planned = planStatements({
+			statements: options.statements.filter(isRenameStatement),
+			fromContract: options.fromContract,
+			contract: options.contract,
+			policy: options.policy,
+			target: {
+				tables: () => sqliteSchemaTables(working.current),
+				renameTableCall: (rename) => sqliteTableRenameCall({
+					previous: working.current,
+					contract: options.contract,
+					rename,
+					frameworkComponents: options.frameworkComponents
+				}),
+				renameColumnCall: (rename) => sqliteColumnRenameCall({
+					previous: working.current,
+					contract: options.contract,
+					rename,
+					frameworkComponents: options.frameworkComponents
+				}),
+				apply: (call) => working.apply(call),
+				...sqliteTableRenameByHand
+			}
+		});
+		if (!planned.ok) return planned;
+		return ok({
+			...planned.value,
+			schema: working.current
+		});
+	}
+	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, schema) {
+		const allowed = options.policy.allowedOperationClasses;
+		const strict = allowed.includes("widening") || allowed.includes("destructive");
+		const { expected, actual, issues: rawIssues } = buildSqlitePlanDiff({
+			contract: options.contract,
+			actualSchema: schema,
+			frameworkComponents: options.frameworkComponents
+		});
+		const owned = retainUnownedExtras(coalesceSubtreeIssues(rawIssues), options.ownership);
+		return {
+			expected,
+			actual,
+			issues: strict ? owned : owned.filter((issue) => issueOutcome(issue) !== "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 (issueOutcome(issue) !== "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 { createSqliteMigrationPlanner as n, SqliteMigrationPlanner as t };
+
+//# sourceMappingURL=planner-BvwYScnt-9H9LIJFn.mjs.map

package/dist/planner-BvwYScnt-9H9LIJFn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-BvwYScnt-9H9LIJFn.mjs","names":["#lowerer"],"sources":["../../../../3-targets/sqlite/1-target/dist/planner-BvwYScnt.mjs"],"sourcesContent":["import { a as sqliteTableRenameByHand, c as sqliteSchemaTables, d as coalesceSubtreeIssues, f as conflictForDisallowedCall, g as buildSqlitePlanDiff, h as sqlitePlannerStrategies, i as sqliteColumnRenameCall, l as indexNameCaseChange, m as planIssues, n as renameTableByHandStatements, o as sqliteTableRenameCall, p as issueNode, r as renderRenameTableCall, s as createWorkingSchema, u as pairIndexReplacements, v as sqliteActualSchema } from \"./sqlite-migration-BAdSmooi.mjs\";\nimport { a as DropColumnCall, c as RawSqlCall, l as RecreateTableCall, s as DropTableCall } from \"./op-factory-call-emj9Xp05.mjs\";\nimport { t as TypeScriptRenderableSqliteMigration } from \"./planner-produced-sqlite-migration-D2jtaItv.mjs\";\nimport { isRenameStatement, issueOutcome } from \"@internal/framework-components/control\";\nimport { appliedStatementsInOrder, backfillOfDefaultedField, columnTakesTemporaryValue, detectTableNameCaseChanges, extractCodecControlHooks, fieldEventStorage, fieldStatementColumns, planFieldEventCalls, planStatements, plannerFailure, sqlTypeLookupsOf, storageNameOfOperation, subjectsOfCalls, unknownCallNames } from \"@internal/family-sql/control\";\nimport { RelationalSchemaNodeKind, SqlTableIR } from \"@internal/sql-schema-ir/types\";\nimport { UNBOUND_NAMESPACE_ID } from \"@internal/framework-components/ir\";\nimport { ok } from \"@internal/utils/result\";\n//#region src/core/migrations/operation-subjects.ts\nfunction lost(target, loss = \"drop\") {\n\treturn {\n\t\t...target,\n\t\tloss\n\t};\n}\nfunction tableTarget(table) {\n\treturn {\n\t\tstorageName: table,\n\t\ttable: {\n\t\t\tnamespaceId: UNBOUND_NAMESPACE_ID,\n\t\t\ttable,\n\t\t\tcolumn: void 0\n\t\t}\n\t};\n}\nfunction columnTarget(table, column) {\n\treturn {\n\t\tstorageName: `${table}.${column}`,\n\t\ttable: {\n\t\t\tnamespaceId: UNBOUND_NAMESPACE_ID,\n\t\t\ttable,\n\t\t\tcolumn\n\t\t}\n\t};\n}\nfunction operationCountOf(call) {\n\treturn \"companions\" in call && Array.isArray(call.companions) ? 1 + call.companions.length : 1;\n}\n/**\n* The columns a recreate loses: those the new table leaves out, whose values the copy drops, and,\n* when the recreate is destructive, those whose type it changes with no copy expression to convert them.\n*/\nfunction recreateLosses(call) {\n\tconst kept = new Set(call.contractTable.columns.map((column) => column.name));\n\tconst dropped = call.schemaColumnNames.filter((column) => !kept.has(column));\n\tconst retyped = call.operationClass === \"destructive\" ? call.retypedColumns.filter((column) => !Object.hasOwn(call.copyExpressions, column)) : [];\n\treturn [...dropped.map((column) => ({\n\t\tcolumn,\n\t\tloss: \"drop\"\n\t})), ...retyped.map((column) => ({\n\t\tcolumn,\n\t\tloss: \"typeChange\"\n\t}))];\n}\n/** The columns a recreate adds with a value its copy writes into every existing row. */\nfunction temporaryValuesOf(call) {\n\tconst copied = new Set(call.schemaColumnNames);\n\treturn Object.entries(call.temporaryValues).flatMap(([column, expression]) => copied.has(column) || expression.kind !== \"sql\" ? [] : [{\n\t\ttable: call.tableName,\n\t\tcolumn,\n\t\tvalue: expression.sql\n\t}]);\n}\n/**\n* What each call of a SQLite plan loses. A recreate that leaves a column out loses its values\n* itself, so a later drop of that column is not listed again.\n*/\nfunction sqliteCallSubjects(calls, fieldEvents) {\n\tconst lostColumns = /* @__PURE__ */ new Set();\n\tconst unknownNames = unknownCallNames(calls.filter((call) => call.operationClass === \"destructive\" && !(call instanceof RecreateTableCall) && !(call instanceof DropColumnCall) && !(call instanceof DropTableCall) && !(call instanceof RawSqlCall) && !fieldEvents.has(call)));\n\treturn calls.map((call) => {\n\t\tconst operationCount = operationCountOf(call);\n\t\tconst { label } = call;\n\t\tif (call instanceof RecreateTableCall) {\n\t\t\tconst columns = recreateLosses(call);\n\t\t\tfor (const { column } of columns) lostColumns.add(`${call.tableName}.${column}`);\n\t\t\treturn {\n\t\t\t\toperationCount,\n\t\t\t\tlabel,\n\t\t\t\tdataLoss: columns.length === 0 && call.operationClass === \"destructive\" ? [lost(tableTarget(call.tableName))] : columns.map(({ column, loss }) => lost(columnTarget(call.tableName, column), loss)),\n\t\t\t\taccessChanges: [],\n\t\t\t\ttemporaryValues: temporaryValuesOf(call)\n\t\t\t};\n\t\t}\n\t\tif (call instanceof DropColumnCall) return {\n\t\t\toperationCount,\n\t\t\tlabel,\n\t\t\tdataLoss: lostColumns.has(`${call.tableName}.${call.columnName}`) ? [] : [lost(columnTarget(call.tableName, call.columnName))],\n\t\t\taccessChanges: [],\n\t\t\ttemporaryValues: []\n\t\t};\n\t\tif (call instanceof DropTableCall) return {\n\t\t\toperationCount,\n\t\t\tlabel,\n\t\t\tdataLoss: [lost(tableTarget(call.tableName))],\n\t\t\taccessChanges: [],\n\t\t\ttemporaryValues: []\n\t\t};\n\t\tif (call.operationClass !== \"destructive\") return {\n\t\t\toperationCount,\n\t\t\tlabel,\n\t\t\tdataLoss: [],\n\t\t\taccessChanges: [],\n\t\t\ttemporaryValues: []\n\t\t};\n\t\tconst fieldEvent = fieldEvents.get(call);\n\t\treturn {\n\t\t\toperationCount,\n\t\t\tlabel,\n\t\t\tdataLoss: [lost(call instanceof RawSqlCall ? {\n\t\t\t\tstorageName: storageNameOfOperation(call.op),\n\t\t\t\ttable: void 0\n\t\t\t} : fieldEvent !== void 0 ? fieldEventStorage(fieldEvent) : {\n\t\t\t\tstorageName: unknownNames.get(call) ?? call.factoryName,\n\t\t\t\ttable: void 0\n\t\t\t})],\n\t\t\taccessChanges: [],\n\t\t\ttemporaryValues: []\n\t\t};\n\t});\n}\n//#endregion\n//#region src/core/migrations/planner.ts\nfunction createSqliteMigrationPlanner(lowerer) {\n\treturn new SqliteMigrationPlanner(lowerer);\n}\n/**\n* SQLite migration planner — a thin wrapper over `planIssues`.\n*\n* `plan()` diffs the live schema against the target contract via the one\n* differ (`buildSqlitePlanDiff`, producing node-typed `SchemaDiffIssue[]`)\n* and delegates to `planIssues` with the registered strategies. Strategies\n* absorb groups of related issues into composite recipes (e.g. recreating a\n* table to apply type/nullability/default/constraint changes at once);\n* anything not absorbed by a strategy flows through `mapNodeIssueToCall` in\n* the issue planner as a one-off call.\n*\n* FK-backing indexes are already merged into the expected table node's\n* `indexes` at derivation (`contractToSchemaIR`'s `convertTable`), so\n* `mapNodeIssueToCall` handles them uniformly alongside user-declared\n* indexes — no separate expansion step in the planner.\n*/\nvar SqliteMigrationPlanner = class {\n\t#lowerer;\n\tconstructor(lowerer) {\n\t\tthis.#lowerer = lowerer;\n\t}\n\tplan(options) {\n\t\treturn this.planSql(options);\n\t}\n\temptyMigration(context, spaceId) {\n\t\treturn new TypeScriptRenderableSqliteMigration([], {\n\t\t\tfrom: context.fromHash,\n\t\t\tto: context.toHash\n\t\t}, spaceId, context.snapshotsImportPath, void 0, this.#lowerer);\n\t}\n\tplanSql(options) {\n\t\tconst policyResult = this.ensureAdditivePolicy(options.policy);\n\t\tif (policyResult) return policyResult;\n\t\tconst statements = this.planStatements(options);\n\t\tif (!statements.ok) return plannerFailure([statements.failure]);\n\t\tconst { expected, actual, issues: diffIssues } = this.collectSchemaIssues(options, statements.value.schema);\n\t\tconst replacedIndexes = pairIndexReplacements(diffIssues, indexNameCaseChange);\n\t\tconst disallowedIndexCalls = replacedIndexes.calls.filter((call) => !options.policy.allowedOperationClasses.includes(call.operationClass));\n\t\tif (disallowedIndexCalls.length > 0) return plannerFailure(disallowedIndexCalls.map((call) => conflictForDisallowedCall(call, options.policy.allowedOperationClasses)));\n\t\tconst issues = diffIssues.filter((issue) => !replacedIndexes.consumed.has(issue));\n\t\tconst caseChangeConflicts = detectTableNameCaseChanges({\n\t\t\tissues,\n\t\t\ttableOf: (issue) => {\n\t\t\t\tconst node = issueNode(issue);\n\t\t\t\treturn node instanceof SqlTableIR ? node : void 0;\n\t\t\t},\n\t\t\tnamespaceIdOf: () => UNBOUND_NAMESPACE_ID,\n\t\t\trenameByHandStatements: renameTableByHandStatements,\n\t\t\trenameTableCall: renderRenameTableCall,\n\t\t\tcontract: options.contract,\n\t\t\tdefaultNamespaceId: UNBOUND_NAMESPACE_ID\n\t\t});\n\t\tif (caseChangeConflicts.length > 0) return plannerFailure(caseChangeConflicts);\n\t\tconst defaultedBackfill = backfillOfDefaultedField(options.statements, options.fromContract, options.contract);\n\t\tif (defaultedBackfill !== void 0) return plannerFailure([defaultedBackfill]);\n\t\tconst codecHooks = extractCodecControlHooks(options.frameworkComponents);\n\t\tconst result = planIssues({\n\t\t\tissues,\n\t\t\texpected,\n\t\t\tactual,\n\t\t\tpolicy: options.policy,\n\t\t\tframeworkComponents: options.frameworkComponents,\n\t\t\tstatementColumns: fieldStatementColumns(options.statements, options.contract),\n\t\t\toriginCodecId: (table, column) => options.fromContract?.storage.namespaces[UNBOUND_NAMESPACE_ID]?.entries.table?.[table]?.columns[column]?.codecId,\n\t\t\ttakesTemporaryValue: (table, column) => {\n\t\t\t\tconst storageTable = options.contract.storage.namespaces[UNBOUND_NAMESPACE_ID]?.entries.table?.[table];\n\t\t\t\treturn storageTable !== void 0 && columnTakesTemporaryValue(storageTable, column);\n\t\t\t},\n\t\t\tstrategies: sqlitePlannerStrategies\n\t\t});\n\t\tif (!result.ok) return plannerFailure(result.failure);\n\t\tconst fieldEventCalls = planFieldEventCalls({\n\t\t\tpriorContract: options.origin === null ? null : options.fromContract,\n\t\t\tnewContract: options.contract,\n\t\t\tcodecHooks,\n\t\t\ttableRenames: statements.value.tableRenames,\n\t\t\tcolumnRenames: statements.value.columnRenames,\n\t\t\tdataTypes: sqlTypeLookupsOf(options.frameworkComponents).dataTypeLookup\n\t\t});\n\t\tconst fieldEventOps = fieldEventCalls.map(({ call }) => call);\n\t\tconst calls = [\n\t\t\t...statements.value.calls,\n\t\t\t...replacedIndexes.calls,\n\t\t\t...result.value.calls,\n\t\t\t...fieldEventOps\n\t\t];\n\t\tconst destination = {\n\t\t\tstorageHash: options.contract.storage.storageHash,\n\t\t\t...options.contract.profileHash !== void 0 ? { profileHash: options.contract.profileHash } : {}\n\t\t};\n\t\treturn {\n\t\t\tkind: \"success\",\n\t\t\tplan: new TypeScriptRenderableSqliteMigration(calls, {\n\t\t\t\tfrom: options.origin?.storageHash ?? null,\n\t\t\t\tto: options.contract.storage.storageHash\n\t\t\t}, options.spaceId, options.snapshotsImportPath, destination, this.#lowerer),\n\t\t\tappliedStatements: appliedStatementsInOrder(options.statements, statements.value.appliedStatements),\n\t\t\t...subjectsOfCalls(sqliteCallSubjects(calls, new Map(fieldEventCalls.map((fieldEvent) => [fieldEvent.call, fieldEvent]))), {\n\t\t\t\tfromContract: options.fromContract,\n\t\t\t\tcontract: options.contract,\n\t\t\t\torigins: statements.value.origins,\n\t\t\t\tbyHand: sqliteTableRenameByHand\n\t\t\t})\n\t\t};\n\t}\n\t/**\n\t* Plans the statements against a working copy of the schema the plan starts from, in order, so\n\t* each rename's index replacements are computed against the schema the earlier statements left.\n\t* The diff then runs on that schema.\n\t*/\n\tplanStatements(options) {\n\t\tconst working = createWorkingSchema(sqliteActualSchema(options.schema));\n\t\tconst planned = planStatements({\n\t\t\tstatements: options.statements.filter(isRenameStatement),\n\t\t\tfromContract: options.fromContract,\n\t\t\tcontract: options.contract,\n\t\t\tpolicy: options.policy,\n\t\t\ttarget: {\n\t\t\t\ttables: () => sqliteSchemaTables(working.current),\n\t\t\t\trenameTableCall: (rename) => sqliteTableRenameCall({\n\t\t\t\t\tprevious: working.current,\n\t\t\t\t\tcontract: options.contract,\n\t\t\t\t\trename,\n\t\t\t\t\tframeworkComponents: options.frameworkComponents\n\t\t\t\t}),\n\t\t\t\trenameColumnCall: (rename) => sqliteColumnRenameCall({\n\t\t\t\t\tprevious: working.current,\n\t\t\t\t\tcontract: options.contract,\n\t\t\t\t\trename,\n\t\t\t\t\tframeworkComponents: options.frameworkComponents\n\t\t\t\t}),\n\t\t\t\tapply: (call) => working.apply(call),\n\t\t\t\t...sqliteTableRenameByHand\n\t\t\t}\n\t\t});\n\t\tif (!planned.ok) return planned;\n\t\treturn ok({\n\t\t\t...planned.value,\n\t\t\tschema: working.current\n\t\t});\n\t}\n\tensureAdditivePolicy(policy) {\n\t\tif (!policy.allowedOperationClasses.includes(\"additive\")) return plannerFailure([{\n\t\t\tkind: \"unsupportedOperation\",\n\t\t\tsummary: \"Migration planner requires additive operations be allowed\",\n\t\t\twhy: \"The planner requires the \\\"additive\\\" operation class to be allowed in the policy.\"\n\t\t}]);\n\t\treturn null;\n\t}\n\t/**\n\t* Diffs the target contract against the live schema via the one differ\n\t* (the same tree-building `diffSqliteSchema` uses, plus the\n\t* op-render stamper) and prepares the issue list `planIssues` consumes.\n\t*\n\t* Three passes, in order:\n\t* 1. Subtree coalescing — the differ is total (a missing/extra table also\n\t*    emits an issue for every column/constraint under it); those nested\n\t*    issues are redundant once the table-level `CreateTable`/`DropTable`\n\t*    call already accounts for the whole subtree. Runs FIRST, over the\n\t*    complete diff: a sibling-owned extra table's column issues must\n\t*    collapse into its one table-level issue before the ownership pass,\n\t*    because a bare column node carries no table reference — if coalescing\n\t*    ran after ownership dropped the table-level issue, the orphaned column\n\t*    issues would survive and the planner would emit drops against a\n\t*    sibling space's table.\n\t* 2. Ownership — a live extra is only this plan's to drop when no contract\n\t*    space owns it. The differ ran against THIS space's contract, so a\n\t*    table a sibling owns surfaces here as `not-expected`; the planner asks\n\t*    the ownership oracle (the passive aggregate) whether any space declares\n\t*    it and, if so, leaves it alone. A table no space owns stays a genuine\n\t*    extra. Ownership lives in the aggregate; the planner only asks. No\n\t*    oracle (single-space) keeps every extra.\n\t* 3. Strict-mode extras gating — `not-expected` (extra table/column/\n\t*    constraint) issues are dropped entirely outside strict mode, mirroring\n\t*    the retired coordinate walk's `if (strict) { ...extra_* } }` guards:\n\t*    an additive-only plan must never even consider dropping an unclaimed\n\t*    object, not just refuse to emit the drop.\n\t*/\n\tcollectSchemaIssues(options, schema) {\n\t\tconst allowed = options.policy.allowedOperationClasses;\n\t\tconst strict = allowed.includes(\"widening\") || allowed.includes(\"destructive\");\n\t\tconst { expected, actual, issues: rawIssues } = buildSqlitePlanDiff({\n\t\t\tcontract: options.contract,\n\t\t\tactualSchema: schema,\n\t\t\tframeworkComponents: options.frameworkComponents\n\t\t});\n\t\tconst owned = retainUnownedExtras(coalesceSubtreeIssues(rawIssues), options.ownership);\n\t\treturn {\n\t\t\texpected,\n\t\t\tactual,\n\t\t\tissues: strict ? owned : owned.filter((issue) => issueOutcome(issue) !== \"not-expected\")\n\t\t};\n\t}\n};\n/**\n* Drops a `not-expected` issue when it is a whole extra TABLE that some\n* contract space owns, asking the ownership oracle per node.\n*\n* The consultation applies ONLY to table-level extras — a live table this\n* space's contract lacks — identified by asking the issue's own node\n* (`nodeKind === table`), never by counting path segments. SQLite is a\n* single-namespace target, so every coordinate is qualified with the shared\n* `UNBOUND_NAMESPACE_ID` sentinel (the same one the aggregate's declared\n* entities carry for this target). `entityKind` is the literal `'table'`:\n* this function only ever asks about a node already confirmed to be\n* `RelationalSchemaNodeKind.table` (checked just above), and that's a\n* diff-tree `nodeKind` spelling (`'sql-table'`) distinct from the storage\n* `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal\n* is that storage-entries spelling. `declaresEntity` answers over the whole\n* composition (self included), so a positive answer on such a table means\n* another space owns it (a table this space owned would be in its expected\n* tree, never an extra): leave it. A negative answer means no space owns\n* it — a genuine orphan to drop.\n*\n* A DEEPER extra (an extra column/constraint on a table this space DOES own —\n* only the child drifted, so the table is in the expected tree) is this\n* space's own drift and is always kept for dropping; asking the oracle there\n* would wrongly suppress it, because the owned table answers `true`. No oracle\n* ⇒ every extra is kept (single-space plan).\n*/\nfunction retainUnownedExtras(issues, ownership) {\n\tif (ownership === void 0) return issues;\n\treturn issues.filter((issue) => {\n\t\tif (issueOutcome(issue) !== \"not-expected\") return true;\n\t\tconst node = issueNode(issue);\n\t\tif (node === void 0 || node.nodeKind !== RelationalSchemaNodeKind.table) return true;\n\t\tconst tableName = issue.path[1];\n\t\treturn tableName === void 0 || !ownership.declaresEntity({\n\t\t\tnamespaceId: UNBOUND_NAMESPACE_ID,\n\t\t\tentityKind: \"table\",\n\t\t\tentityName: tableName\n\t\t});\n\t});\n}\n//#endregion\nexport { createSqliteMigrationPlanner as n, SqliteMigrationPlanner as t };\n\n//# sourceMappingURL=planner-BvwYScnt.mjs.map"],"mappings":"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"}

package/dist/{planner-Bxdi7jZF.d.mts → planner-CjMq9oEt.d.mts}

@@ -1,16 +1,20 @@
-import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz-CMahymzq.mjs";
-import { n as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-BuJysRxx-CaDUbNVx.mjs";
-import { MigrationPlanner, MigrationScaffoldContext, SchemaOwnership } from "@prisma/orm-framework/components/control";
-import { MigrationOperationPolicy, SqlMigrationPlanner, SqlPlannerFailureResult } from "@prisma/orm-family-sql/family/control";
-import { Contract } from "@prisma/orm-framework/contract/types";
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz-BrBPQGOS.mjs";
+import { n as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-DuM9c3YI-Dacb6zQZ.mjs";
+import { AppliedMigrationStatement, MigrationAccessChange, MigrationDataLoss, MigrationPlanner, MigrationScaffoldContext, MigrationTemporaryValue, PlanOrigin, ResolvedMigrationStatement, SchemaOwnership } from "@prisma/orm-framework/components/control";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { MigrationOperationPolicy, SqlMigrationPlanner, SqlPlannerFailureResult } from "@prisma/orm-family-sql/family/control";
 import { ExecuteRequestLowerer } from "@prisma/orm-family-sql/family/control-adapter";
-//#region ../../../3-targets/3-targets/sqlite/dist/planner.d.mts
+import { Contract } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-targets/sqlite/1-target/dist/planner.d.mts
 //#region src/core/migrations/planner.d.ts
 declare function createSqliteMigrationPlanner(lowerer: ExecuteRequestLowerer): SqliteMigrationPlanner;
 type SqlitePlanResult = {
   readonly kind: 'success';
   readonly plan: TypeScriptRenderableSqliteMigration;
+  readonly appliedStatements: readonly AppliedMigrationStatement[];
+  readonly dataLoss: readonly MigrationDataLoss[];
+  readonly accessChanges: readonly MigrationAccessChange[];
+  readonly temporaryValues: readonly MigrationTemporaryValue[];
 } | SqlPlannerFailureResult;
 /**
  * SQLite migration planner — a thin wrapper over `planIssues`.
@@ -41,11 +45,12 @@ declare class SqliteMigrationPlanner implements SqlMigrationPlanner<SqlitePlanTa
      *
      * Typed as the framework `Contract | null` to satisfy the
      * `MigrationPlanner` interface contract; `planSql` narrows to the SQL
-     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate
-     * `describe().from` on the produced plan as
-     * `fromContract?.storage.storageHash ?? null`.
+     * shape via `SqlMigrationPlannerPlanOptions`.
      */
     readonly fromContract: Contract | null;
+    /** The origin the produced plan asserts: its `describe().from` and `origin`. */
+    readonly origin: PlanOrigin | null;
+    readonly statements: readonly ResolvedMigrationStatement[];
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
     /**
      * Contract space this plan applies to. Stamped onto the produced
@@ -67,6 +72,12 @@ declare class SqliteMigrationPlanner implements SqlMigrationPlanner<SqlitePlanTa
   }): SqlitePlanResult;
   emptyMigration(context: MigrationScaffoldContext, spaceId: string): TypeScriptRenderableSqliteMigration;
   private planSql;
+  /**
+   * Plans the statements against a working copy of the schema the plan starts from, in order, so
+   * each rename's index replacements are computed against the schema the earlier statements left.
+   * The diff then runs on that schema.
+   */
+  private planStatements;
   private ensureAdditivePolicy;
   /**
    * Diffs the target contract against the live schema via the one differ
@@ -101,4 +112,4 @@ declare class SqliteMigrationPlanner implements SqlMigrationPlanner<SqlitePlanTa
 }
 //#endregion
 export { SqlitePlanResult as n, createSqliteMigrationPlanner as r, SqliteMigrationPlanner as t };
-//# sourceMappingURL=planner-Bxdi7jZF.d.mts.map
+//# sourceMappingURL=planner-CjMq9oEt.d.mts.map

package/dist/planner-CjMq9oEt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-CjMq9oEt.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/planner.d.mts"],"mappings":";;;;;;;;;iBAQiB,6BAA6B,SAAS,wBAAwB;KAC1E;WACM;WACA,MAAM;WACN,4BAA4B;WAC5B,mBAAmB;WACnB,wBAAwB;WACxB,0BAA0B;IACjC;;;;;;;;;;;;;;;;;cAiBU,kCAAkC,oBAAoB,0BAA0B;;EAE5F,YAAY,SAAS;EACrB,KAAK;aACM;aACA;aACA,QAAQ;;;;;;;;;aASR,cAAc;;aAEd,QAAQ;aACR,qBAAqB;aACrB,qBAAqB,cAAc;;;;;;aAMnC;;;;;aAKA,YAAY;;;;;;aAMZ;MACP;EACJ,eAAe,SAAS,0BAA0B,kBAAkB;UAC5D;;;;;;UAMA;UACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BA"}

package/dist/{planner-produced-sqlite-migration-C9uVDKrJ-CWbxSANn.mjs → planner-produced-sqlite-migration-D2jtaItv-ZFZhPfGE.mjs}

@@ -1,10 +1,10 @@
-import { t as renderOps } from "./render-ops-KxAmAz6d-W2xyvA5y.mjs";
-import { t as SqliteMigration } from "./sqlite-migration-CjMkH4Id-c6dM9w61.mjs";
+import { t as SqliteMigration } from "./sqlite-migration-BAdSmooi-iWFVQgGV.mjs";
+import { t as renderOps } from "./render-ops-BPLkHR-y-CPoXG5Ap.mjs";
 import { contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier } from "@prisma/orm-framework/components/control";
 import { renderImports } from "@prisma/orm-framework/ts-render";
 import { resolveRequirementSpecifiers } from "@prisma/orm-framework/components/emission";
 import { detectScaffoldRuntime, shebangLineFor } from "@prisma/orm-toolchain/migration-tools/migration-ts";
-//#region ../../../3-targets/3-targets/sqlite/dist/planner-produced-sqlite-migration-C9uVDKrJ.mjs
+//#region ../../../3-targets/sqlite/1-target/dist/planner-produced-sqlite-migration-D2jtaItv.mjs
 /**
 * Polymorphic TypeScript emitter for the SQLite migration IR. Mirrors the
 * Postgres `render-typescript.ts` — different base-class + factory module
@@ -147,4 +147,4 @@ var TypeScriptRenderableSqliteMigration = class extends SqliteMigration {
 //#endregion
 export { TypeScriptRenderableSqliteMigration as t };
 
-//# sourceMappingURL=planner-produced-sqlite-migration-C9uVDKrJ-CWbxSANn.mjs.map
+//# sourceMappingURL=planner-produced-sqlite-migration-D2jtaItv-ZFZhPfGE.mjs.map

package/dist/planner-produced-sqlite-migration-D2jtaItv-ZFZhPfGE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-sqlite-migration-D2jtaItv-ZFZhPfGE.mjs","names":["#calls","#meta","#spaceId","#snapshotsImportPath","#destination","#lowerer","#operationsCache"],"sources":["../../../../3-targets/sqlite/1-target/dist/planner-produced-sqlite-migration-D2jtaItv.mjs"],"sourcesContent":["import { t as SqliteMigration } from \"./sqlite-migration-BAdSmooi.mjs\";\nimport { t as renderOps } from \"./render-ops-BPLkHR-y.mjs\";\nimport { contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier } from \"@internal/framework-components/control\";\nimport { renderImports } from \"@internal/ts-render\";\nimport { resolveRequirementSpecifiers } from \"@internal/framework-components/emission\";\nimport { detectScaffoldRuntime, shebangLineFor } from \"@internal/migration-tools/migration-ts\";\n//#region src/core/migrations/render-typescript.ts\n/**\n* Polymorphic TypeScript emitter for the SQLite migration IR. Mirrors the\n* Postgres `render-typescript.ts` — different base-class + factory module\n* specifier, same overall shape.\n*/\n/**\n* Always-present base imports for the rendered scaffold. Both come from\n* `@internal/sqlite/migration` so an authored SQLite\n* `migration.ts` only needs a single dependency for its base class and\n* its CLI entrypoint. Mirrors Postgres's `BASE_IMPORTS`.\n*\n* - `Migration` — the facade re-export fixes the `SqlMigration`\n*   generic to `SqlitePlanTargetDetails` and the abstract `targetId` to\n*   `'sqlite'`.\n* - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n*   `@internal/cli/migration-cli`. Loads `prisma.config.ts`,\n*   assembles a `ControlStack`, and instantiates the migration class.\n*/\nconst BASE_IMPORTS = [{\n\tmoduleSpecifier: \"@internal/sqlite/migration\",\n\tsymbol: \"Migration\"\n}, {\n\tmoduleSpecifier: \"@internal/sqlite/migration\",\n\tsymbol: \"MigrationCLI\"\n}];\nfunction renderCallsToTypeScript(calls, meta) {\n\tconst imports = buildImports(calls, meta);\n\tconst operationsBody = calls.map((c) => c.renderTypeScript()).join(\",\\n\");\n\tconst hasStart = meta.from !== null;\n\tconst startField = hasStart ? [\"  override readonly startContractJson = startContract;\"] : [];\n\treturn [\n\t\tshebangLineFor(detectScaffoldRuntime()),\n\t\timports,\n\t\t\"\",\n\t\t`export default class M extends Migration<${hasStart ? \"Start\" : \"never\"}, End> {`,\n\t\t...startField,\n\t\t\"  override readonly endContractJson = endContract;\",\n\t\t\"\",\n\t\t\"  override get operations() {\",\n\t\t\"    return [\",\n\t\tindent(operationsBody, 6),\n\t\t\"    ];\",\n\t\t\"  }\",\n\t\t\"}\",\n\t\t\"\",\n\t\t\"MigrationCLI.run(import.meta.url, M);\",\n\t\t\"\"\n\t].join(\"\\n\");\n}\nfunction buildImports(calls, meta) {\n\tconst requirements = [...BASE_IMPORTS, ...contractImports(meta)];\n\tfor (const call of calls) for (const req of call.importRequirements()) requirements.push(req);\n\treturn renderImports(resolveRequirementSpecifiers(requirements, meta.resolveImportSpecifier));\n}\n/**\n* The committed contract-JSON imports the scaffold reads its from/to identity\n* from, resolved to the deduplicated snapshot store under\n* `meta.snapshotsImportPath`. The end snapshot is always present; the start\n* snapshot is added only for a non-baseline migration (`meta.from !== null`).\n* The matching `Contract` type imports (aliased `Start`/`End`) feed the\n* `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with\n* no start imports — `never` is the honest \"no prior contract\" Start.\n*/\nfunction contractImports(meta) {\n\tconst reqs = [{\n\t\tmoduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.to),\n\t\tsymbol: \"endContract\",\n\t\tkind: \"default\",\n\t\tattributes: { type: \"json\" }\n\t}, {\n\t\tmoduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.to),\n\t\tsymbol: \"Contract\",\n\t\talias: \"End\",\n\t\ttypeOnly: true\n\t}];\n\tif (meta.from !== null) {\n\t\treqs.push({\n\t\t\tmoduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.from),\n\t\t\tsymbol: \"startContract\",\n\t\t\tkind: \"default\",\n\t\t\tattributes: { type: \"json\" }\n\t\t});\n\t\treqs.push({\n\t\t\tmoduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.from),\n\t\t\tsymbol: \"Contract\",\n\t\t\talias: \"Start\",\n\t\t\ttypeOnly: true\n\t\t});\n\t}\n\treturn reqs;\n}\nfunction indent(text, spaces) {\n\tconst pad = \" \".repeat(spaces);\n\treturn text.split(\"\\n\").map((line) => line.trim() ? `${pad}${line}` : line).join(\"\\n\");\n}\n//#endregion\n//#region src/core/migrations/planner-produced-sqlite-migration.ts\nvar TypeScriptRenderableSqliteMigration = class extends SqliteMigration {\n\t#calls;\n\t#meta;\n\t#destination;\n\t#spaceId;\n\t#snapshotsImportPath;\n\t#lowerer;\n\t#operationsCache;\n\tconstructor(calls, meta, spaceId, snapshotsImportPath, destination, lowerer) {\n\t\tsuper();\n\t\tthis.#calls = calls;\n\t\tthis.#meta = meta;\n\t\tthis.#spaceId = spaceId;\n\t\tthis.#snapshotsImportPath = snapshotsImportPath;\n\t\tthis.#destination = destination ?? { storageHash: meta.to };\n\t\tthis.#lowerer = lowerer;\n\t}\n\tget operations() {\n\t\tthis.#operationsCache ??= renderOps(this.#calls, this.#lowerer);\n\t\treturn this.#operationsCache;\n\t}\n\tdescribe() {\n\t\treturn this.#meta;\n\t}\n\tget destination() {\n\t\treturn this.#destination;\n\t}\n\t/**\n\t* Contract space this planner-produced plan applies to. Threaded\n\t* from {@link SqlMigrationPlannerPlanOptions.spaceId} so the runner\n\t* keys the marker row by the right space when executing the plan.\n\t*/\n\tget spaceId() {\n\t\treturn this.#spaceId;\n\t}\n\trenderTypeScript(resolveImportSpecifier) {\n\t\treturn renderCallsToTypeScript(this.#calls, {\n\t\t\tfrom: this.#meta.from,\n\t\t\tto: this.#meta.to,\n\t\t\tsnapshotsImportPath: this.#snapshotsImportPath,\n\t\t\tresolveImportSpecifier\n\t\t});\n\t}\n};\n//#endregion\nexport { TypeScriptRenderableSqliteMigration as t };\n\n//# sourceMappingURL=planner-produced-sqlite-migration-D2jtaItv.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,eAAe,CAAC;CACrB,iBAAiB;CACjB,QAAQ;AACT,GAAG;CACF,iBAAiB;CACjB,QAAQ;AACT,CAAC;AACD,SAAS,wBAAwB,OAAO,MAAM;CAC7C,MAAM,UAAU,aAAa,OAAO,IAAI;CACxC,MAAM,iBAAiB,MAAM,KAAK,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,KAAK;CACxE,MAAM,WAAW,KAAK,SAAS;CAC/B,MAAM,aAAa,WAAW,CAAC,wDAAwD,IAAI,CAAC;CAC5F,OAAO;EACN,eAAe,sBAAsB,CAAC;EACtC;EACA;EACA,4CAA4C,WAAW,UAAU,QAAQ;EACzE,GAAG;EACH;EACA;EACA;EACA;EACA,OAAO,gBAAgB,CAAC;EACxB;EACA;EACA;EACA;EACA;EACA;CACD,CAAC,CAAC,KAAK,IAAI;AACZ;AACA,SAAS,aAAa,OAAO,MAAM;CAClC,MAAM,eAAe,CAAC,GAAG,cAAc,GAAG,gBAAgB,IAAI,CAAC;CAC/D,KAAK,MAAM,QAAQ,OAAO,KAAK,MAAM,OAAO,KAAK,mBAAmB,GAAG,aAAa,KAAK,GAAG;CAC5F,OAAO,cAAc,6BAA6B,cAAc,KAAK,sBAAsB,CAAC;AAC7F;;;;;;;;;;AAUA,SAAS,gBAAgB,MAAM;CAC9B,MAAM,OAAO,CAAC;EACb,iBAAiB,8BAA8B,KAAK,qBAAqB,KAAK,EAAE;EAChF,QAAQ;EACR,MAAM;EACN,YAAY,EAAE,MAAM,OAAO;CAC5B,GAAG;EACF,iBAAiB,+BAA+B,KAAK,qBAAqB,KAAK,EAAE;EACjF,QAAQ;EACR,OAAO;EACP,UAAU;CACX,CAAC;CACD,IAAI,KAAK,SAAS,MAAM;EACvB,KAAK,KAAK;GACT,iBAAiB,8BAA8B,KAAK,qBAAqB,KAAK,IAAI;GAClF,QAAQ;GACR,MAAM;GACN,YAAY,EAAE,MAAM,OAAO;EAC5B,CAAC;EACD,KAAK,KAAK;GACT,iBAAiB,+BAA+B,KAAK,qBAAqB,KAAK,IAAI;GACnF,QAAQ;GACR,OAAO;GACP,UAAU;EACX,CAAC;CACF;CACA,OAAO;AACR;AACA,SAAS,OAAO,MAAM,QAAQ;CAC7B,MAAM,MAAM,IAAI,OAAO,MAAM;CAC7B,OAAO,KAAK,MAAM,IAAI,CAAC,CAAC,KAAK,SAAS,KAAK,KAAK,IAAI,GAAG,MAAM,SAAS,IAAI,CAAC,CAAC,KAAK,IAAI;AACtF;AAGA,IAAI,sCAAsC,cAAc,gBAAgB;CACvE;CACA;CACA;CACA;CACA;CACA;CACA;CACA,YAAY,OAAO,MAAM,SAAS,qBAAqB,aAAa,SAAS;EAC5E,MAAM;EACN,KAAKA,SAAS;EACd,KAAKC,QAAQ;EACb,KAAKC,WAAW;EAChB,KAAKC,uBAAuB;EAC5B,KAAKC,eAAe,eAAe,EAAE,aAAa,KAAK,GAAG;EAC1D,KAAKC,WAAW;CACjB;CACA,IAAI,aAAa;EAChB,KAAKC,qBAAqB,UAAU,KAAKN,QAAQ,KAAKK,QAAQ;EAC9D,OAAO,KAAKC;CACb;CACA,WAAW;EACV,OAAO,KAAKL;CACb;CACA,IAAI,cAAc;EACjB,OAAO,KAAKG;CACb;;;;;;CAMA,IAAI,UAAU;EACb,OAAO,KAAKF;CACb;CACA,iBAAiB,wBAAwB;EACxC,OAAO,wBAAwB,KAAKF,QAAQ;GAC3C,MAAM,KAAKC,MAAM;GACjB,IAAI,KAAKA,MAAM;GACf,qBAAqB,KAAKE;GAC1B;EACD,CAAC;CACF;AACD"}

package/dist/{planner-produced-sqlite-migration-BuJysRxx-CaDUbNVx.d.mts → planner-produced-sqlite-migration-DuM9c3YI-Dacb6zQZ.d.mts}

@@ -1,11 +1,11 @@
-import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz-CMahymzq.mjs";
-import { t as SqliteMigration } from "./sqlite-migration-o23JHwzY-CwNJcqwl.mjs";
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz-BrBPQGOS.mjs";
+import { t as SqliteMigration } from "./sqlite-migration-CLIMaHLy-5ZjJDdDP.mjs";
 import { MigrationPlanWithAuthoringSurface, OpFactoryCall } from "@prisma/orm-framework/components/control";
 import { SqlMigrationPlanOperation } from "@prisma/orm-family-sql/family/control";
 import { MigrationMeta } from "@prisma/orm-toolchain/migration-tools/migration";
 import { ImportSpecifierResolver } from "@prisma/orm-framework/components/emission";
 import { ExecuteRequestLowerer } from "@prisma/orm-family-sql/family/control-adapter";
-//#region ../../../3-targets/3-targets/sqlite/dist/planner-produced-sqlite-migration-BuJysRxx.d.mts
+//#region ../../../3-targets/sqlite/1-target/dist/planner-produced-sqlite-migration-DuM9c3YI.d.mts
 //#region src/core/migrations/planner-produced-sqlite-migration.d.ts
 type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 interface SqliteMigrationDestinationInfo {
@@ -28,4 +28,4 @@ declare class TypeScriptRenderableSqliteMigration extends SqliteMigration implem
 }
 //#endregion
 export { TypeScriptRenderableSqliteMigration as n, SqliteMigrationDestinationInfo as t };
-//# sourceMappingURL=planner-produced-sqlite-migration-BuJysRxx-CaDUbNVx.d.mts.map
+//# sourceMappingURL=planner-produced-sqlite-migration-DuM9c3YI-Dacb6zQZ.d.mts.map

package/dist/planner-produced-sqlite-migration-DuM9c3YI-Dacb6zQZ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-sqlite-migration-DuM9c3YI-Dacb6zQZ.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/planner-produced-sqlite-migration-DuM9c3YI.d.mts"],"mappings":";;;;;;;;;KAQK,KAAK,0BAA0B;UAC1B;WACC;WACA;;cAEG,4CAA4C,2BAA2B;;EAEnF,YAAY,gBAAgB,iBAAiB,MAAM,eAAe,iBAAiB,6BAA6B,cAAc,gCAAgC,UAAU;MACpK,wBAAwB,KAAK,QAAQ;EACzC,YAAY;MACR,eAAe;;;;;;MAMf;EACJ,iBAAiB,wBAAwB"}

package/dist/planner-produced-sqlite-migration-GDP1M36D.d.mts

@@ -0,0 +1 @@
+import "./planner-produced-sqlite-migration-DuM9c3YI-Dacb6zQZ.mjs";

package/dist/{planner-target-details-CIQ789Gc-C5U4yVY9.mjs → planner-target-details-CIQ789Gc-Cug2V5g5.mjs}

@@ -1,5 +1,5 @@
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-//#region ../../../3-targets/3-targets/sqlite/dist/planner-target-details-CIQ789Gc.mjs
+//#region ../../../3-targets/sqlite/1-target/dist/planner-target-details-CIQ789Gc.mjs
 const DEFAULT_SCHEMA = "main";
 function buildTargetDetails(objectType, name, table) {
 	return {
@@ -12,4 +12,4 @@ function buildTargetDetails(objectType, name, table) {
 //#endregion
 export { buildTargetDetails as t };
 
-//# sourceMappingURL=planner-target-details-CIQ789Gc-C5U4yVY9.mjs.map
+//# sourceMappingURL=planner-target-details-CIQ789Gc-Cug2V5g5.mjs.map

package/dist/planner-target-details-CIQ789Gc-Cug2V5g5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-target-details-CIQ789Gc-Cug2V5g5.mjs","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/planner-target-details-CIQ789Gc.mjs"],"sourcesContent":["import { ifDefined } from \"@internal/utils/defined\";\n//#region src/core/migrations/planner-target-details.ts\nconst DEFAULT_SCHEMA = \"main\";\nfunction buildTargetDetails(objectType, name, table) {\n\treturn {\n\t\tschema: DEFAULT_SCHEMA,\n\t\tobjectType,\n\t\tname,\n\t\t...ifDefined(\"table\", table)\n\t};\n}\n//#endregion\nexport { buildTargetDetails as t };\n\n//# sourceMappingURL=planner-target-details-CIQ789Gc.mjs.map"],"mappings":";;AAEA,MAAM,iBAAiB;AACvB,SAAS,mBAAmB,YAAY,MAAM,OAAO;CACpD,OAAO;EACN,QAAQ;EACR;EACA;EACA,GAAG,UAAU,SAAS,KAAK;CAC5B;AACD"}

package/dist/{planner-target-details-xR6UfIcz-CMahymzq.d.mts → planner-target-details-xR6UfIcz-BrBPQGOS.d.mts}

@@ -1,4 +1,4 @@
-//#region ../../../3-targets/3-targets/sqlite/dist/planner-target-details-xR6UfIcz.d.mts
+//#region ../../../3-targets/sqlite/1-target/dist/planner-target-details-xR6UfIcz.d.mts
 //#region src/core/migrations/planner-target-details.d.ts
 type OperationClass = 'table' | 'column' | 'primaryKey' | 'unique' | 'index' | 'foreignKey';
 interface SqlitePlanTargetDetails {
@@ -10,4 +10,4 @@ interface SqlitePlanTargetDetails {
 declare function buildTargetDetails(objectType: OperationClass, name: string, table?: string): SqlitePlanTargetDetails;
 //#endregion
 export { buildTargetDetails as n, SqlitePlanTargetDetails as t };
-//# sourceMappingURL=planner-target-details-xR6UfIcz-CMahymzq.d.mts.map
+//# sourceMappingURL=planner-target-details-xR6UfIcz-BrBPQGOS.d.mts.map

package/dist/planner-target-details-xR6UfIcz-BrBPQGOS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-target-details-xR6UfIcz-BrBPQGOS.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/planner-target-details-xR6UfIcz.d.mts"],"mappings":";;KACK;UACK;WACC;WACA,YAAY;WACZ;WACA;;iBAEM,mBAAmB,YAAY,gBAAgB,cAAc,iBAAiB"}