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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/orm-target-sqlite",
-  "version": "8.0.0-rc.19-dev.1",
+  "version": "8.0.0-rc.19-dev.2",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -9,19 +9,19 @@
     "dist"
   ],
   "dependencies": {
-    "@prisma/orm-family-sql": "8.0.0-rc.19-dev.1",
-    "@prisma/orm-framework": "8.0.0-rc.19-dev.1",
-    "@prisma/orm-toolchain": "8.0.0-rc.19-dev.1",
+    "@prisma/orm-family-sql": "8.0.0-rc.19-dev.2",
+    "@prisma/orm-framework": "8.0.0-rc.19-dev.2",
+    "@prisma/orm-toolchain": "8.0.0-rc.19-dev.2",
     "@standard-schema/spec": "1.1.0",
     "arktype": "^2.2.2",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@internal/adapter-sqlite": "8.0.0-rc.19-dev.1",
-    "@internal/driver-sqlite": "8.0.0-rc.19-dev.1",
-    "@internal/target-sqlite": "8.0.0-rc.19-dev.1",
-    "@repo/tsconfig": "8.0.0-rc.19-dev.1",
-    "@repo/tsdown": "8.0.0-rc.19-dev.1",
+    "@internal/adapter-sqlite": "8.0.0-rc.19-dev.2",
+    "@internal/driver-sqlite": "8.0.0-rc.19-dev.2",
+    "@internal/target-sqlite": "8.0.0-rc.19-dev.2",
+    "@repo/tsconfig": "8.0.0-rc.19-dev.2",
+    "@repo/tsdown": "8.0.0-rc.19-dev.2",
     "tsdown": "0.22.14",
     "typescript": "5.9.3"
   },

package/dist/control-Oq9sp9Tq.mjs

@@ -1,574 +0,0 @@
-import { a as SQLITE_INTEGER_CODEC_ID, c as SQLITE_TEXT_CODEC_ID, i as SQLITE_DATETIME_CODEC_ID, o as SQLITE_JSON_CODEC_ID, r as SQLITE_BLOB_CODEC_ID, s as SQLITE_REAL_CODEC_ID, t as SQLITE_BIGINT_CODEC_ID } from "./codec-ids-wgEvkCkg-8bxcCujY.mjs";
-import { n as sqliteError } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
-import { t as sqliteTargetDescriptorMeta } from "./descriptor-meta-B9drv0U6-DoV55ut2.mjs";
-import { r as quoteIdentifier } from "./sql-utils-XGT5Esi2-5k9pvJeF.mjs";
-import { g as conversionCopyOf, p as affinityStorageClasses, y as rebuiltTableName } from "./op-factory-call-Dzsgcf3B-B7IaqEjE.mjs";
-import { t as SqliteContractSerializer } from "./sqlite-contract-view-CJ895eER-n57Mabt2.mjs";
-import { b as verifySqliteDatabaseSchema, h as sqliteContractToSchema, o as diffSqliteSchema } from "./sqlite-migration-B7LD9iDG-BTpw_zNF.mjs";
-import { n as createSqliteMigrationPlanner } from "./planner-DD8nGrZ_-BcGCsYVP.mjs";
-import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { APP_SPACE_ID, failedPrecheckWhy, schemaCheckWhy, withFailingSpace } from "@prisma/orm-framework/components/control";
-import { convertedColumnOf, fieldOfColumn, requiredColumnsOfMigration, rowsWithoutValueFailure, runnerFailure, runnerSuccess, sqlTypeLookupsOf, unconvertedFieldOf } from "@prisma/orm-family-sql/family/control";
-import { relationalNodeEntityKind, relationalNodeGranularity } from "@prisma/orm-family-sql/schema-ir/types";
-import { SqlStorage } from "@prisma/orm-family-sql/contract/types";
-import { SqlSchemaVerifierBase } from "@prisma/orm-family-sql/family/ir";
-import { notOk, ok, okVoid } from "@prisma/orm-framework/utils/result";
-import { SqlQueryError } from "@prisma/orm-family-sql/errors";
-//#region ../../../3-targets/3-targets/sqlite/dist/control.mjs
-const NOT_NULL_VIOLATION_SQLSTATE = "23502";
-function createSqliteMigrationRunner(family) {
-	return new SqliteMigrationRunner(family);
-}
-var SqliteMigrationRunner = class {
-	family;
-	constructor(family) {
-		this.family = family;
-	}
-	/**
-	* Apply the plan against an already-open connection without managing
-	* the transaction lifecycle. The caller ({@link SqliteMigrationRunner.execute})
-	* owns BEGIN/COMMIT/ROLLBACK and any connection-level setup (FK pragma
-	* toggle, FK integrity check).
-	*/
-	async executeOnConnection(options) {
-		const driver = options.driver;
-		if (options.space !== void 0 && options.space !== options.plan.spaceId) throw sqliteError("MIGRATION.CONTRACT_SPACE_VIOLATION", `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`, { meta: {
-			space: options.space,
-			planSpaceId: options.plan.spaceId
-		} });
-		const space = options.plan.spaceId;
-		const planOps = blindCast(await Promise.all(options.plan.operations));
-		const destinationCheck = this.ensurePlanMatchesDestinationContract(options.plan.destination, options.destinationContract);
-		if (!destinationCheck.ok) return destinationCheck;
-		const policyCheck = this.enforcePolicyCompatibility(options.policy, planOps);
-		if (!policyCheck.ok) return policyCheck;
-		const ensureResult = await this.ensureControlTables(driver, options.destinationContract);
-		if (!ensureResult.ok) return ensureResult;
-		const existingMarker = await this.family.readMarker({
-			driver,
-			space
-		});
-		const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
-		if (!markerCheck.ok) return markerCheck;
-		const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
-		const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
-		const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
-		let operationsExecuted;
-		let executedOperations;
-		if (skipOperations) {
-			operationsExecuted = 0;
-			executedOperations = [];
-		} else {
-			const applyResult = await this.applyPlan(driver, options, planOps);
-			if (!applyResult.ok) return applyResult;
-			operationsExecuted = applyResult.value.operationsExecuted;
-			executedOperations = applyResult.value.executedOperations;
-		}
-		if (space === APP_SPACE_ID) {
-			const schemaNode = await this.family.introspect({
-				driver,
-				contract: options.destinationContract
-			});
-			const schemaVerifyResult = verifySqliteDatabaseSchema({
-				contract: options.destinationContract,
-				actualSchema: schemaNode,
-				strict: options.strictVerification ?? true,
-				frameworkComponents: options.frameworkComponents
-			});
-			if (!schemaVerifyResult.ok) return runnerFailure("MIGRATION.SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
-				why: schemaCheckWhy(schemaVerifyResult.schema.issues),
-				meta: { schemaIssues: schemaVerifyResult.schema.issues }
-			});
-		}
-		const incomingInvariants = options.plan.providedInvariants;
-		const existingInvariants = new Set(existingMarker?.invariants ?? []);
-		const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariants.has(id));
-		if (!(isSelfEdge && operationsExecuted === 0 && incomingIsSubsetOfExisting)) {
-			const markerResult = await this.upsertMarker(driver, options, existingMarker, space);
-			if (!markerResult.ok) return markerResult;
-			await this.recordLedgerEntries(driver, options, executedOperations);
-		}
-		return runnerSuccess({
-			operationsPlanned: planOps.length,
-			operationsExecuted
-		});
-	}
-	async execute(options) {
-		const driver = options.driver;
-		const perSpaceOptions = options.perSpaceOptions;
-		if (perSpaceOptions.length === 0) return ok({ perSpaceResults: [] });
-		const fkWasEnabled = await this.readForeignKeysEnabled(driver);
-		if (fkWasEnabled) await driver.query("PRAGMA foreign_keys = OFF");
-		try {
-			await this.beginExclusiveTransaction(driver);
-			let committed = false;
-			try {
-				const perSpaceResults = [];
-				let lastProcessedSpace;
-				for (const spaceOptions of perSpaceOptions) {
-					const space = spaceOptions.space ?? spaceOptions.plan.spaceId;
-					const result = await this.executeOnConnection({
-						...spaceOptions,
-						driver,
-						space
-					});
-					if (!result.ok) return notOk(withFailingSpace(result.failure, space));
-					perSpaceResults.push({
-						space,
-						value: result.value
-					});
-					lastProcessedSpace = space;
-				}
-				if (fkWasEnabled) {
-					const fkIntegrityCheck = await this.verifyForeignKeyIntegrity(driver);
-					if (!fkIntegrityCheck.ok) return notOk(withFailingSpace(fkIntegrityCheck.failure, lastProcessedSpace ?? APP_SPACE_ID));
-				}
-				await this.commitTransaction(driver);
-				committed = true;
-				return ok({ perSpaceResults });
-			} finally {
-				if (!committed) await this.rollbackTransaction(driver);
-			}
-		} finally {
-			if (fkWasEnabled) await driver.query("PRAGMA foreign_keys = ON");
-		}
-	}
-	async readForeignKeysEnabled(driver) {
-		return (await driver.query("PRAGMA foreign_keys")).rows[0]?.foreign_keys === 1;
-	}
-	async verifyForeignKeyIntegrity(driver) {
-		const result = await driver.query("PRAGMA foreign_key_check");
-		if (result.rows.length === 0) return okVoid();
-		return runnerFailure("MIGRATION.FOREIGN_KEY_VIOLATION", `Foreign key integrity check failed after migration: ${result.rows.length} violation(s).`, {
-			why: "PRAGMA foreign_key_check reported violations after applying recreate-table operations.",
-			meta: { violations: result.rows }
-		});
-	}
-	async applyPlan(driver, options, ops) {
-		const checks = options.executionChecks;
-		const runPrechecks = checks?.prechecks !== false;
-		const runPostchecks = checks?.postchecks !== false;
-		const runIdempotency = checks?.idempotencyChecks !== false;
-		let operationsExecuted = 0;
-		const executedOperations = [];
-		for (const operation of ops) {
-			options.callbacks?.onOperationStart?.(operation);
-			try {
-				if (runPostchecks && runIdempotency) {
-					if (await this.expectationsAreSatisfied(driver, operation.postcheck)) {
-						executedOperations.push(this.createSkipRecord(operation));
-						continue;
-					}
-				}
-				if (runPrechecks) {
-					const precheckResult = await this.runExpectationSteps(driver, operation.precheck, operation, "precheck");
-					if (!precheckResult.ok) return precheckResult;
-				}
-				const executeResult = await this.runExecuteSteps(driver, operation.execute, operation, {
-					contract: options.destinationContract,
-					operationIndex: ops.indexOf(operation),
-					operations: ops,
-					edges: options.migrationEdges
-				});
-				if (!executeResult.ok) return executeResult;
-				if (runPostchecks) {
-					const postcheckResult = await this.runExpectationSteps(driver, operation.postcheck, operation, "postcheck", {
-						contract: options.destinationContract,
-						operationIndex: ops.indexOf(operation)
-					});
-					if (!postcheckResult.ok) return postcheckResult;
-				}
-				executedOperations.push(operation);
-				operationsExecuted += 1;
-			} finally {
-				options.callbacks?.onOperationComplete?.(operation);
-			}
-		}
-		return ok({
-			operationsExecuted,
-			executedOperations
-		});
-	}
-	async ensureControlTables(driver, contract) {
-		const lowererContext = { contract };
-		for (const query of this.family.bootstrapControlTableQueries()) await this.executeStatement(driver, await this.family.lowerAst(query, lowererContext));
-		return okVoid();
-	}
-	async runExpectationSteps(driver, steps, operation, phase, plan) {
-		for (const step of steps) {
-			const result = await driver.query(step.sql, step.params ?? []);
-			if (!this.stepResultIsTrue(result.rows)) {
-				const code = phase === "precheck" ? "MIGRATION.PRECHECK_FAILED" : "MIGRATION.POSTCHECK_FAILED";
-				const field = plan === void 0 ? void 0 : unconvertedFieldOf(step, plan.contract);
-				const converted = convertedColumnOf(step);
-				const failedCheck = {
-					operationId: operation.id,
-					phase,
-					description: step.description
-				};
-				const unconverted = converted === void 0 ? void 0 : await this.unconvertedValueText(driver, converted);
-				return runnerFailure(code, `Operation ${operation.id} failed during ${phase}: ${step.description}`, {
-					...ifDefined("why", unconverted ?? (phase === "precheck" ? failedPrecheckWhy(failedCheck) : void 0)),
-					meta: {
-						failedCheck,
-						...ifDefined("failedTypeChange", field === void 0 || plan === void 0 || converted === void 0 ? void 0 : converted.by === "conversion" ? {
-							field,
-							by: "conversion",
-							reason: "invalidResult",
-							operationIndex: plan.operationIndex
-						} : {
-							field,
-							by: "cast",
-							reason: "value",
-							operationIndex: plan.operationIndex
-						})
-					}
-				});
-			}
-		}
-		return okVoid();
-	}
-	/** Names the first value of a retyped column that kept a storage class its new type does not hold. */
-	async unconvertedValueText(driver, cast) {
-		const typeSql = (await driver.query("SELECT type FROM pragma_table_info(?) WHERE name = ?", [cast.table, cast.column])).rows[0]?.type;
-		if (typeSql === void 0) return void 0;
-		const column = quoteIdentifier(cast.column);
-		const classes = ["null", ...affinityStorageClasses(typeSql)];
-		const row = (await driver.query(`SELECT quote(${column}) AS value, typeof(${column}) AS storageClass FROM ${quoteIdentifier(cast.table)} WHERE typeof(${column}) NOT IN (${classes.map(() => "?").join(", ")}) LIMIT 1`, classes)).rows[0];
-		if (row === void 0) return void 0;
-		return `The value ${row.value.length > 40 ? `${row.value.slice(0, 40)}…` : row.value} of column "${cast.column}" on "${cast.table}" is still stored as ${row.storageClass}, which ${typeSql} cannot hold.`;
-	}
-	async runExecuteSteps(driver, steps, operation, plan) {
-		for (const step of steps) try {
-			await driver.query(step.sql, step.params ?? []);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			const failed = `Operation ${operation.id} failed during execution: ${step.description}`;
-			const rowsWithoutValue = await this.rowsWithoutValue(driver, error, plan);
-			const failedConversion = rowsWithoutValue === void 0 ? await this.failedConversion(driver, step, error, plan) : void 0;
-			return runnerFailure("MIGRATION.EXECUTION_FAILED", rowsWithoutValue?.summary ?? failed, {
-				why: rowsWithoutValue === void 0 ? message : `${failed}: ${message}`,
-				meta: {
-					operationId: operation.id,
-					stepDescription: step.description,
-					sql: step.sql,
-					...ifDefined("rowsWithoutValue", rowsWithoutValue?.reports),
-					...ifDefined("failedTypeChange", failedConversion)
-				}
-			});
-		}
-		return okVoid();
-	}
-	/**
-	* The conversion that failed, when the failed step is the copy of a rebuild that converts columns
-	* and there is evidence for it: a copy expression that fails on its own has an error in its
-	* expression, and a constraint of the new table that names a converted column was broken by a
-	* value the conversion produced. Any other failure of the copy is not the conversion's.
-	*/
-	async failedConversion(driver, step, error, plan) {
-		const copy = conversionCopyOf(step);
-		if (copy === void 0) return void 0;
-		const columns = Object.keys(copy.expressions);
-		const failed = async (column) => {
-			try {
-				await driver.query(`SELECT ${copy.expressions[column]} FROM ${quoteIdentifier(copy.table)}`);
-				return false;
-			} catch {
-				return true;
-			}
-		};
-		for (const column of columns) if (await failed(column)) return this.conversionOf(plan, copy.table, column, "expressionError");
-		const constrainedList = SqlQueryError.is(error) ? error.constraint : void 0;
-		if (constrainedList === void 0) return void 0;
-		const constrained = new Set(constrainedList.split(", "));
-		const column = columns.find((name) => constrained.has(`${rebuiltTableName(copy.table)}.${name}`));
-		return column === void 0 ? void 0 : this.conversionOf(plan, copy.table, column, "invalidResult");
-	}
-	conversionOf(plan, table, column, reason) {
-		const field = fieldOfColumn(plan.contract, table, column);
-		return field === void 0 ? void 0 : {
-			field,
-			by: "conversion",
-			reason,
-			operationIndex: plan.operationIndex
-		};
-	}
-	/**
-	* The rows a table rebuild found no value for, when its copy failed on a NOT NULL column of the
-	* new table: the columns the rebuild's postchecks mark as becoming required are counted, the
-	* rebuild's own first, then those of every other operation of its migration.
-	*/
-	rowsWithoutValue(driver, error, plan) {
-		if (!(SqlQueryError.is(error) && error.sqlState === NOT_NULL_VIOLATION_SQLSTATE)) return Promise.resolve(void 0);
-		const marks = requiredColumnsOfMigration(plan.operations, plan.edges, plan.operationIndex);
-		return rowsWithoutValueFailure({
-			failed: marks.filter((mark) => mark.operationIndex === plan.operationIndex),
-			others: marks,
-			count: async ({ required }) => {
-				const where = required.reason !== "newField" ? ` WHERE ${quoteIdentifier(required.column)} IS NULL` : "";
-				return (await driver.query(`SELECT COUNT(*) AS rows FROM ${quoteIdentifier(required.table)}${where}`)).rows[0]?.rows ?? 0;
-			},
-			contract: plan.contract
-		});
-	}
-	stepResultIsTrue(rows) {
-		if (!rows || rows.length === 0) return false;
-		const firstRow = rows[0];
-		const firstValue = firstRow ? Object.values(firstRow)[0] : void 0;
-		if (typeof firstValue === "number") return firstValue !== 0;
-		if (typeof firstValue === "boolean") return firstValue;
-		if (typeof firstValue === "string") {
-			const lower = firstValue.toLowerCase();
-			if (lower === "true" || lower === "1") return true;
-			if (lower === "false" || lower === "0") return false;
-			return firstValue.length > 0;
-		}
-		return Boolean(firstValue);
-	}
-	async expectationsAreSatisfied(driver, steps) {
-		if (steps.length === 0) return false;
-		for (const step of steps) {
-			const result = await driver.query(step.sql, step.params ?? []);
-			if (!this.stepResultIsTrue(result.rows)) return false;
-		}
-		return true;
-	}
-	createSkipRecord(operation) {
-		return Object.freeze({
-			id: operation.id,
-			label: operation.label,
-			...ifDefined("summary", operation.summary),
-			operationClass: operation.operationClass,
-			target: operation.target,
-			precheck: Object.freeze([]),
-			execute: Object.freeze([]),
-			postcheck: Object.freeze([...operation.postcheck]),
-			meta: Object.freeze({
-				...operation.meta ?? {},
-				runner: Object.freeze({
-					skipped: true,
-					reason: "postcheck_pre_satisfied"
-				})
-			})
-		});
-	}
-	markerMatchesDestination(marker, plan) {
-		if (!marker) return false;
-		if (marker.storageHash !== plan.destination.storageHash) return false;
-		if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) return false;
-		return true;
-	}
-	enforcePolicyCompatibility(policy, operations) {
-		const allowedClasses = new Set(policy.allowedOperationClasses);
-		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("MIGRATION.POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
-			why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
-			meta: {
-				operationId: operation.id,
-				operationClass: operation.operationClass,
-				allowedClasses: policy.allowedOperationClasses
-			}
-		});
-		return okVoid();
-	}
-	ensureMarkerCompatibility(marker, plan) {
-		const origin = plan.origin ?? null;
-		if (!origin) return okVoid();
-		if (!marker) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
-		if (marker.storageHash !== origin.storageHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
-			markerStorageHash: marker.storageHash,
-			expectedOriginStorageHash: origin.storageHash
-		} });
-		if (origin.profileHash && marker.profileHash !== origin.profileHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`, { meta: {
-			markerProfileHash: marker.profileHash,
-			expectedOriginProfileHash: origin.profileHash
-		} });
-		return okVoid();
-	}
-	ensurePlanMatchesDestinationContract(destination, contract) {
-		if (destination.storageHash !== contract.storage.storageHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storage.storageHash}).`, { meta: {
-			planStorageHash: destination.storageHash,
-			contractStorageHash: contract.storage.storageHash
-		} });
-		if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`, { meta: {
-			planProfileHash: destination.profileHash,
-			contractProfileHash: contract.profileHash
-		} });
-		return okVoid();
-	}
-	async upsertMarker(driver, options, existingMarker, space) {
-		const destination = {
-			storageHash: options.plan.destination.storageHash,
-			profileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.storageHash,
-			invariants: options.plan.providedInvariants ?? []
-		};
-		if (!existingMarker) {
-			await this.family.initMarker({
-				driver,
-				space,
-				destination
-			});
-			return okVoid();
-		}
-		if (!await this.family.updateMarker({
-			driver,
-			space,
-			expectedFrom: existingMarker.storageHash,
-			destination
-		})) {
-			const found = await this.family.readMarker({
-				driver,
-				space
-			});
-			return runnerFailure("MIGRATION.MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
-				space,
-				expectedStorageHash: existingMarker.storageHash,
-				foundStorageHash: found?.storageHash ?? null,
-				destinationStorageHash: options.plan.destination.storageHash
-			} });
-		}
-		return okVoid();
-	}
-	async recordLedgerEntries(driver, options, executedOperations) {
-		const plan = options.plan;
-		const space = plan.spaceId;
-		const edges = options.migrationEdges;
-		const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
-		if (totalEdgeOps !== plan.operations.length) throw new InternalError(`Ledger write: plan.operations length (${plan.operations.length}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`);
-		let offset = 0;
-		for (const edge of edges) {
-			const edgeOps = executedOperations.slice(offset, offset + edge.operationCount);
-			offset += edge.operationCount;
-			await this.family.writeLedgerEntry({
-				driver,
-				space,
-				entry: {
-					edgeId: `${edge.from}->${edge.to}`,
-					from: edge.from,
-					to: edge.to,
-					migrationName: edge.dirName,
-					migrationHash: edge.migrationHash,
-					operations: edgeOps
-				}
-			});
-		}
-	}
-	async beginExclusiveTransaction(driver) {
-		await driver.query("BEGIN EXCLUSIVE");
-	}
-	async commitTransaction(driver) {
-		await driver.query("COMMIT");
-	}
-	async rollbackTransaction(driver) {
-		await driver.query("ROLLBACK");
-	}
-	async executeStatement(driver, statement) {
-		await driver.query(statement.sql, statement.params);
-	}
-};
-/**
-* SQLite target `SchemaVerifier` concretion. Mirrors the Postgres
-* shape: hooks return the empty list pending the call-site migration
-* that routes the existing verifier behaviour through the SPI.
-*/
-var SqliteSchemaVerifier = class extends SqlSchemaVerifierBase {
-	verifyCommonSqlSchema(_options) {
-		return [];
-	}
-	verifyTargetExtensions(_options) {
-		return [];
-	}
-};
-function isSqlContract(contract) {
-	return contract === null || contract.storage instanceof SqlStorage;
-}
-const sqliteControlTargetDescriptor = {
-	...sqliteTargetDescriptorMeta,
-	contractSerializer: new SqliteContractSerializer(),
-	schemaVerifier: new SqliteSchemaVerifier(),
-	diffSchema(input) {
-		return diffSqliteSchema(input);
-	},
-	classifySubjectGranularity: relationalNodeGranularity,
-	classifyEntityKind: relationalNodeEntityKind,
-	migrations: {
-		createPlanner(adapter) {
-			return createSqliteMigrationPlanner(adapter);
-		},
-		createRunner(family) {
-			return createSqliteMigrationRunner(family);
-		},
-		contractToSchema(contract, frameworkComponents) {
-			if (!isSqlContract(contract)) throw sqliteError("CONTRACT.TARGET_MISMATCH", "sqliteControlTargetDescriptor.contractToSchema received a non-SQL contract; expected Contract<SqlStorage>");
-			return sqliteContractToSchema(contract, sqlTypeLookupsOf(frameworkComponents));
-		}
-	},
-	create() {
-		return {
-			familyId: "sql",
-			targetId: "sqlite"
-		};
-	},
-	createPlanner(adapter) {
-		return createSqliteMigrationPlanner(adapter);
-	},
-	createRunner(family) {
-		return createSqliteMigrationRunner(family);
-	}
-};
-/**
-* The base PSL scalars as zero-arg type constructors in the unified authoring
-* channel. Each names a codec; the column's database type is its data type's.
-*
-* The type position is the only storage decider: a mutation-default generator
-* (`@onCreate(uuid())`) never re-picks a column's storage.
-*
-* These are the constructors only PSL offers. They are defined here, next to the codecs they name, but the adapter contributes them: the TypeScript contract builder builds its `type.*` helpers from the target, so a target contribution would add `type.String()` and the like there. The constructors that should also be `type.*` helpers are the target's own (`sqliteAuthoringTypes`).
-*/
-const sqlitePslTypeConstructors = {
-	String: {
-		kind: "typeConstructor",
-		documentation: "Variable-length text stored as SQLite text.",
-		output: { codecId: SQLITE_TEXT_CODEC_ID }
-	},
-	Int: {
-		kind: "typeConstructor",
-		documentation: "An integer stored as SQLite integer and represented as a JavaScript number.",
-		output: { codecId: SQLITE_INTEGER_CODEC_ID }
-	},
-	BigInt: {
-		kind: "typeConstructor",
-		documentation: "An integer stored as SQLite integer and represented as a JavaScript bigint.",
-		output: { codecId: SQLITE_BIGINT_CODEC_ID }
-	},
-	Float: {
-		kind: "typeConstructor",
-		documentation: "A floating-point number stored as SQLite real.",
-		output: { codecId: SQLITE_REAL_CODEC_ID }
-	},
-	Decimal: {
-		kind: "typeConstructor",
-		documentation: "A decimal value stored and represented as text to preserve precision.",
-		output: { codecId: SQLITE_TEXT_CODEC_ID }
-	},
-	DateTime: {
-		kind: "typeConstructor",
-		documentation: "A date and time stored as SQLite text.",
-		output: { codecId: SQLITE_DATETIME_CODEC_ID }
-	},
-	Json: {
-		kind: "typeConstructor",
-		documentation: "A JSON value serialized to SQLite text.",
-		output: { codecId: SQLITE_JSON_CODEC_ID }
-	},
-	Bytes: {
-		kind: "typeConstructor",
-		documentation: "Binary data stored as a SQLite blob.",
-		output: { codecId: SQLITE_BLOB_CODEC_ID }
-	}
-};
-//#endregion
-export { sqlitePslTypeConstructors as n, sqliteControlTargetDescriptor as t };
-
-//# sourceMappingURL=control-Oq9sp9Tq.mjs.map