@prisma/orm-target-sqlite 0.16.0-dev.36

package/dist/adapter-wc9p_v2Z-y8pzqMfG.mjs

@@ -0,0 +1,997 @@
+import { n as buildSqliteCodecDescriptorRegistry } from "./codec-descriptor-kVCSW1OR-CPatZUPM.mjs";
+import { r as SQLITE_DATETIME_CODEC_ID } from "./codec-ids-xicqpuAa-DHnKqnIs.mjs";
+import { a as sqliteCodecRegistry, i as sqliteCodecDescriptorRegistry, t as jsonDocumentRetag } from "./codecs-CM_2W3uA.mjs";
+import { a as jsonText, i as integer, n as buildSignMarkerBootstrapQueries, o as sqliteTable, r as datetime, s as text, t as buildControlTableBootstrapQueries } from "./contract-free-DElSXD0q.mjs";
+import { n as quoteIdentifier, t as escapeLiteral } from "./sql-utils-DqPXZBMA-Mm27NNjs.mjs";
+import { t as parseSqliteDefault } from "./default-normalizer-DuoHj9-O-DsK7lJZn.mjs";
+import { t as normalizeSqliteNativeType } from "./native-type-normalizer-GpQMEyN5.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { RawExpr, isDdlNode } from "@prisma/orm-family-sql/relational-core/ast";
+import { APP_SPACE_ID, extractCodecLookup } from "@prisma/orm-framework/components/control";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { RelationalSchemaNodeKind, SqlSchemaIR, SqlTableIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { parseMarkerRowSafely, withMarkerReadErrorHandling } from "@prisma/orm-framework/errors/execution";
+import { parseContractMarkerRow } from "@prisma/orm-family-sql/family/verify";
+import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma/orm-family-sql/runtime";
+//#region ../../../3-targets/6-adapters/sqlite/dist/adapter-wc9p_v2Z.mjs
+function descriptorsFrom(contributors) {
+	return contributors.flatMap((contributor) => contributor.types?.codecTypes?.codecDescriptors ?? []);
+}
+function buildSqliteCodecRegistry(descriptors) {
+	const descriptorRegistry = buildSqliteCodecDescriptorRegistry(descriptors);
+	const registry = {
+		...extractCodecLookup([{
+			id: "sqlite-codecs",
+			types: { codecTypes: { codecDescriptors: Array.from(descriptorRegistry.values()) } }
+		}]),
+		descriptorFor: (codecId) => descriptorRegistry.descriptorFor(codecId),
+		values: () => descriptorRegistry.values()
+	};
+	return Object.freeze(registry);
+}
+function assembleSqliteCodecRegistry(target, extensions) {
+	return buildSqliteCodecRegistry([
+		...descriptorsFrom([target]),
+		...sqliteCodecDescriptorRegistry.values(),
+		...descriptorsFrom(extensions)
+	]);
+}
+function createSqliteCodecRegistryWithBuiltins(codecDescriptors = []) {
+	return buildSqliteCodecRegistry([...sqliteCodecDescriptorRegistry.values(), ...codecDescriptors]);
+}
+/**
+* Build a coherent SQLite codec registry populated with built-in descriptors only.
+*
+* The returned registry supports both ordinary codec materialization and SQLite target behavior. Stack-composed paths build the same combined registry from target, full adapter, and ordered extension contributions.
+*/
+function createSqliteBuiltinCodecLookup() {
+	return createSqliteCodecRegistryWithBuiltins();
+}
+function ledgerOriginFromStored(originCoreHash) {
+	if (originCoreHash === null || originCoreHash === "" || originCoreHash === "empty") return null;
+	return originCoreHash;
+}
+const CONTROL_CODECS = createAstCodecRegistry(sqliteCodecRegistry);
+async function encodeControlQueryParams(lowered, ast, codecs = CONTROL_CODECS) {
+	return encodeParamsWithMetadata(lowered.params.map((slot) => {
+		if (slot.kind === "literal") return slot.value;
+		throw new InternalError(`control query lowered to a bind slot '${slot.name}', which is unsupported`);
+	}), deriveParamMetadata(ast), {}, codecs);
+}
+const DESIGNATOR_LESS_UTC_DATETIME = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d+)?$/;
+function coerceLedgerAppliedAt(value) {
+	if (value instanceof Date) return value;
+	if (DESIGNATOR_LESS_UTC_DATETIME.test(value)) return /* @__PURE__ */ new Date(`${value.replace(" ", "T")}Z`);
+	return new Date(value);
+}
+function operationCountFromStored(operations) {
+	if (Array.isArray(operations)) return operations.length;
+	if (typeof operations === "string") try {
+		const parsed = JSON.parse(operations);
+		return Array.isArray(parsed) ? parsed.length : 0;
+	} catch {
+		return 0;
+	}
+	return 0;
+}
+const marker = sqliteTable("_prisma_marker", {
+	space: text(),
+	core_hash: text(),
+	profile_hash: text(),
+	contract_json: jsonText({ nullable: true }),
+	canonical_version: integer({ nullable: true }),
+	updated_at: datetime(),
+	app_tag: text({ nullable: true }),
+	meta: jsonText({ nullable: true }),
+	invariants: jsonText()
+});
+/**
+* Writeable subset of `_prisma_ledger`. Omits the DB-generated `id`
+* (`INTEGER PRIMARY KEY AUTOINCREMENT`) and `created_at` (default
+* `strftime(...)`).
+*/
+const ledger = sqliteTable("_prisma_ledger", {
+	space: text(),
+	migration_name: text(),
+	migration_hash: text(),
+	origin_core_hash: text({ nullable: true }),
+	destination_core_hash: text(),
+	operations: jsonText()
+});
+/**
+* Read-side handle covering every column of `_prisma_ledger`, including
+* the DB-generated `id` (for ORDER BY) and `created_at`.
+*/
+const ledgerReadShape = sqliteTable("_prisma_ledger", {
+	id: integer(),
+	space: text(),
+	migration_name: text(),
+	migration_hash: text(),
+	origin_core_hash: text({ nullable: true }),
+	destination_core_hash: text(),
+	operations: jsonText(),
+	created_at: text()
+});
+const sqliteCatalog = sqliteTable("sqlite_master", {
+	type: text(),
+	name: text()
+});
+const NOW = new RawExpr({
+	parts: ["datetime('now')"],
+	returns: {
+		codecId: SQLITE_DATETIME_CODEC_ID,
+		nullable: false
+	}
+});
+function mergeInvariants(current, incoming) {
+	return [.../* @__PURE__ */ new Set([...current, ...incoming])].sort();
+}
+async function execute(lower, driver, query) {
+	const lowered = lower(query);
+	const encoded = await encodeControlQueryParams(lowered, query);
+	return (await driver.query(lowered.sql, encoded)).rows;
+}
+function decodeSqliteMarkerRow(row) {
+	if (typeof row !== "object" || row === null || !("invariants" in row)) return row;
+	const record = row;
+	if (typeof record.invariants !== "string") return row;
+	let parsed;
+	try {
+		parsed = JSON.parse(record.invariants);
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw structuredError("CONTRACT.MARKER_ROW_CORRUPT", `Invalid contract marker row: invariants is not valid JSON: ${detail}`, {
+			meta: { detail },
+			cause: err
+		});
+	}
+	return {
+		...record,
+		invariants: parsed
+	};
+}
+const SQLITE_MARKER_TABLE = "_prisma_marker";
+const SQLITE_LEDGER_TABLE = "_prisma_ledger";
+var SqliteControlAdapter = class {
+	familyId = "sql";
+	targetId = "sqlite";
+	codecRegistry;
+	constructor(codecRegistry) {
+		this.codecRegistry = codecRegistry;
+	}
+	normalizeDefault = parseSqliteDefault;
+	normalizeNativeType = normalizeSqliteNativeType;
+	bootstrapControlTableQueries() {
+		return buildControlTableBootstrapQueries();
+	}
+	bootstrapSignMarkerQueries() {
+		return buildSignMarkerBootstrapQueries();
+	}
+	/**
+	* Lower a SQL query AST into a SQLite-flavored `{ sql, params }` payload.
+	*
+	* Delegates to the shared `renderLoweredSql` renderer so the control adapter
+	* emits byte-identical SQL to `SqliteAdapterImpl.lower()` for the same AST
+	* and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
+	* without instantiating the runtime adapter.
+	*/
+	lower(ast, context) {
+		if (isDdlNode(ast)) throw structuredError("RUNTIME.DDL_UNSUPPORTED", "lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().", { meta: { surface: "control-adapter" } });
+		return renderLoweredSql(ast, blindCast(context.contract), this.codecRegistry);
+	}
+	/**
+	* Lower an AST all the way to a driver-ready statement. For DDL nodes,
+	* literal column defaults are formatted as inline SQL with SQLite-specific
+	* literal syntax (no cast suffix, boolean as 0/1, blob via X'hex'). For
+	* query ASTs, params are kept as `?` placeholders; wire values go in
+	* `params`. Does NOT call `this.lower()` — independent implementation.
+	*/
+	async lowerToExecuteRequest(ast, context) {
+		if (isDdlNode(ast)) return sqliteRenderDdlExecuteRequest(blindCast(ast), this.codecRegistry);
+		const lowered = renderLoweredSql(ast, blindCast(context?.contract), this.codecRegistry);
+		const params = await encodeControlQueryParams(lowered, ast, blindCast(this.codecRegistry));
+		return {
+			sql: lowered.sql,
+			params
+		};
+	}
+	/**
+	* Reads the contract marker from `_prisma_marker`. Probes `sqlite_master`
+	* first so a fresh database (no marker table) returns `null` instead of a
+	* "no such table" error.
+	*/
+	async readMarker(driver, space) {
+		const result = await this.readMarkerDiscriminated(driver, space);
+		return result.kind === "present" ? result.record : null;
+	}
+	async readMarkerDiscriminated(driver, space) {
+		return withMarkerReadErrorHandling(() => this.readMarkerResult(driver, space), {
+			space,
+			markerLocation: SQLITE_MARKER_TABLE
+		});
+	}
+	/**
+	* Reads every row from `_prisma_marker` and returns them keyed by
+	* `space`. Mirrors the existence probe in {@link readMarker}: a
+	* fresh database without the marker table returns an empty map.
+	*/
+	async readAllMarkers(driver) {
+		return withMarkerReadErrorHandling(() => this.readAllMarkersResult(driver), {
+			space: APP_SPACE_ID,
+			markerLocation: SQLITE_MARKER_TABLE
+		});
+	}
+	async readAllMarkersResult(driver) {
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if ((await execute(lower, driver, sqliteCatalog.select(sqliteCatalog.name).where(sqliteCatalog.type.eq("table").and(sqliteCatalog.name.eq("_prisma_marker"))).build())).length === 0) return /* @__PURE__ */ new Map();
+		const rows = blindCast(await execute(lower, driver, marker.select(marker.space, marker.core_hash, marker.profile_hash, marker.contract_json, marker.canonical_version, marker.updated_at, marker.app_tag, marker.meta, marker.invariants).build()));
+		const out = /* @__PURE__ */ new Map();
+		for (const row of rows) out.set(row.space, parseMarkerRowSafely(row, (raw) => parseContractMarkerRow(decodeSqliteMarkerRow(raw)), {
+			space: row.space,
+			markerLocation: SQLITE_MARKER_TABLE
+		}));
+		return out;
+	}
+	/**
+	* Reads per-migration ledger rows from `_prisma_ledger` in apply order.
+	* Probes `sqlite_master` first so a fresh database without the ledger
+	* table returns `[]` instead of raising "no such table".
+	*/
+	async readLedger(driver, space) {
+		return withMarkerReadErrorHandling(() => this.readLedgerResult(driver, space), {
+			space: space ?? "*",
+			markerLocation: SQLITE_LEDGER_TABLE
+		});
+	}
+	async readLedgerResult(driver, space) {
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if ((await execute(lower, driver, sqliteCatalog.select(sqliteCatalog.name).where(sqliteCatalog.type.eq("table").and(sqliteCatalog.name.eq("_prisma_ledger"))).build())).length === 0) return [];
+		const base = ledgerReadShape.select(ledgerReadShape.space, ledgerReadShape.migration_name, ledgerReadShape.migration_hash, ledgerReadShape.origin_core_hash, ledgerReadShape.destination_core_hash, ledgerReadShape.operations, ledgerReadShape.created_at);
+		return blindCast(await execute(lower, driver, (space !== void 0 ? base.where(ledgerReadShape.space.eq(space)) : base).orderBy(ledgerReadShape.id).build())).map((row) => ({
+			space: row.space,
+			migrationName: row.migration_name,
+			migrationHash: row.migration_hash,
+			from: ledgerOriginFromStored(row.origin_core_hash),
+			to: row.destination_core_hash,
+			appliedAt: coerceLedgerAppliedAt(row.created_at),
+			operationCount: operationCountFromStored(row.operations)
+		}));
+	}
+	/**
+	* Stamps the initial marker row for `space` via the shared contract-free DML
+	* builder, lowered through {@link lower} and executed on the driver. See the
+	* `SqlControlAdapter.initMarker` contract.
+	*/
+	async insertMarker(driver, space, destination) {
+		await execute((query) => this.lower(query, { contract: void 0 }), driver, marker.insert({
+			space,
+			core_hash: destination.storageHash,
+			profile_hash: destination.profileHash,
+			contract_json: null,
+			canonical_version: null,
+			updated_at: NOW,
+			app_tag: null,
+			meta: {},
+			invariants: destination.invariants ?? []
+		}).build());
+	}
+	async initMarker(driver, space, destination) {
+		await execute((query) => this.lower(query, { contract: void 0 }), driver, marker.upsert({
+			space,
+			core_hash: destination.storageHash,
+			profile_hash: destination.profileHash,
+			contract_json: null,
+			canonical_version: null,
+			updated_at: NOW,
+			app_tag: null,
+			meta: {},
+			invariants: destination.invariants ?? []
+		}).onConflict(marker.space).doUpdate((excluded) => ({
+			core_hash: excluded.core_hash,
+			profile_hash: excluded.profile_hash,
+			contract_json: excluded.contract_json,
+			canonical_version: excluded.canonical_version,
+			updated_at: NOW,
+			app_tag: excluded.app_tag,
+			meta: excluded.meta,
+			invariants: excluded.invariants
+		})).build());
+	}
+	/**
+	* Compare-and-swap advance of the marker row for `space`. See the
+	* `SqlControlAdapter.updateMarker` contract.
+	*/
+	async updateMarker(driver, space, expectedFrom, destination) {
+		const currentInvariants = destination.invariants === void 0 ? [] : (await this.readMarker(driver, space))?.invariants ?? [];
+		const mergedInvariants = destination.invariants === void 0 ? void 0 : mergeInvariants(currentInvariants, destination.invariants);
+		return (await execute((q) => this.lower(q, { contract: void 0 }), driver, marker.update().set({
+			core_hash: destination.storageHash,
+			profile_hash: destination.profileHash,
+			updated_at: NOW,
+			...mergedInvariants !== void 0 ? { invariants: mergedInvariants } : {}
+		}).where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom))).returning(marker.space).build())).length > 0;
+	}
+	/**
+	* Appends a ledger entry for `space`. See the
+	* `SqlControlAdapter.writeLedgerEntry` contract.
+	*/
+	async writeLedgerEntry(driver, space, entry) {
+		await execute((query) => this.lower(query, { contract: void 0 }), driver, ledger.insert({
+			space,
+			migration_name: entry.migrationName,
+			migration_hash: entry.migrationHash,
+			origin_core_hash: entry.from,
+			destination_core_hash: entry.to,
+			operations: entry.operations
+		}).build());
+	}
+	async readMarkerResult(driver, space) {
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if ((await execute(lower, driver, sqliteCatalog.select(sqliteCatalog.name).where(sqliteCatalog.type.eq("table").and(sqliteCatalog.name.eq("_prisma_marker"))).build())).length === 0) return { kind: "no-table" };
+		const row = (await execute(lower, driver, marker.select(marker.core_hash, marker.profile_hash, marker.contract_json, marker.canonical_version, marker.updated_at, marker.app_tag, marker.meta, marker.invariants).where(marker.space.eq(space)).build()))[0];
+		if (!row) return { kind: "absent" };
+		return {
+			kind: "present",
+			record: parseContractMarkerRow(decodeSqliteMarkerRow(row))
+		};
+	}
+	async introspect(driver, _contract) {
+		const tablesResult = await driver.query(`SELECT name FROM sqlite_master
+       WHERE type = 'table'
+         AND name NOT LIKE 'sqlite_%'
+         AND name NOT IN ('_prisma_marker', '_prisma_ledger')
+       ORDER BY name`);
+		const tables = {};
+		for (const tableRow of tablesResult.rows) {
+			const tableName = tableRow.name;
+			const columnsResult = await driver.query(`PRAGMA table_info("${escapePragmaArg(tableName)}")`);
+			const fkResult = await driver.query(`PRAGMA foreign_key_list("${escapePragmaArg(tableName)}")`);
+			const indexListResult = await driver.query(`PRAGMA index_list("${escapePragmaArg(tableName)}")`);
+			const columns = {};
+			const pkColumns = [];
+			for (const col of columnsResult.rows) {
+				const resolvedNativeType = normalizeSqliteNativeType(col.type);
+				const rawDefault = col.dflt_value ?? void 0;
+				columns[col.name] = {
+					name: col.name,
+					nativeType: col.type.toLowerCase(),
+					nullable: col.notnull === 0 && col.pk === 0,
+					...ifDefined("default", rawDefault),
+					resolvedNativeType,
+					...ifDefined("resolvedDefault", rawDefault !== void 0 ? parseSqliteDefault(rawDefault, resolvedNativeType) : void 0)
+				};
+				if (col.pk > 0) pkColumns.push({
+					name: col.name,
+					pk: col.pk
+				});
+			}
+			pkColumns.sort((a, b) => a.pk - b.pk);
+			const primaryKey = pkColumns.length > 0 ? {
+				columns: pkColumns.map((c) => c.name),
+				dependsOn: flatColumnDependsOn(tableName, pkColumns.map((c) => c.name))
+			} : void 0;
+			const fkMap = /* @__PURE__ */ new Map();
+			for (const fk of fkResult.rows) {
+				const existing = fkMap.get(fk.id);
+				if (existing) {
+					existing.columns.push(fk.from);
+					existing.referencedColumns.push(fk.to);
+				} else fkMap.set(fk.id, {
+					columns: [fk.from],
+					referencedTable: fk.table,
+					referencedColumns: [fk.to],
+					onDelete: fk.on_delete,
+					onUpdate: fk.on_update
+				});
+			}
+			const foreignKeys = Array.from(fkMap.values()).map((fk) => ({
+				columns: Object.freeze([...fk.columns]),
+				referencedTable: fk.referencedTable,
+				referencedColumns: Object.freeze([...fk.referencedColumns]),
+				...ifDefined("onDelete", mapSqliteReferentialAction(fk.onDelete)),
+				...ifDefined("onUpdate", mapSqliteReferentialAction(fk.onUpdate)),
+				dependsOn: [flatTableDependsOn(fk.referencedTable), ...flatColumnDependsOn(tableName, fk.columns)]
+			}));
+			const uniques = [];
+			const indexes = [];
+			for (const idx of indexListResult.rows) {
+				const idxColumns = (await driver.query(`PRAGMA index_info("${escapePragmaArg(idx.name)}")`)).rows.sort((a, b) => a.seqno - b.seqno).map((r) => r.name);
+				if (idx.origin === "u") uniques.push({
+					columns: Object.freeze([...idxColumns]),
+					name: idx.name,
+					dependsOn: flatColumnDependsOn(tableName, idxColumns)
+				});
+				else if (idx.origin === "c") indexes.push({
+					naming: {
+						kind: "exact",
+						name: idx.name
+					},
+					columns: Object.freeze([...idxColumns]),
+					where: void 0,
+					unique: idx.unique === 1,
+					partial: idx.partial === 1,
+					type: void 0,
+					options: void 0,
+					annotations: void 0,
+					dependsOn: flatColumnDependsOn(tableName, idxColumns)
+				});
+			}
+			tables[tableName] = new SqlTableIR({
+				name: tableName,
+				columns,
+				...ifDefined("primaryKey", primaryKey),
+				foreignKeys,
+				uniques,
+				indexes
+			});
+		}
+		return new SqlSchemaIR({ tables });
+	}
+};
+function escapePragmaArg(name) {
+	return name.replace(/"/g, "\"\"");
+}
+const SQLITE_REFERENTIAL_ACTION_MAP = {
+	"NO ACTION": "noAction",
+	RESTRICT: "restrict",
+	CASCADE: "cascade",
+	"SET NULL": "setNull",
+	"SET DEFAULT": "setDefault"
+};
+function mapSqliteReferentialAction(rule) {
+	const normalized = rule.toUpperCase();
+	const mapped = SQLITE_REFERENTIAL_ACTION_MAP[normalized];
+	if (mapped === void 0) throw structuredError("CONTRACT.INTROSPECTION_UNSUPPORTED", `Unknown SQLite referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`, { meta: { rule } });
+	if (mapped === "noAction") return void 0;
+	return mapped;
+}
+/**
+* The referenced table's chain in the flat (single-schema) tree this
+* introspection builds: the root (`SqlSchemaIR`, fixed `'database'` id)
+* followed by the table's own id. Mirrors the expected-side derivation
+* (`contractToSchemaIR`'s `convertForeignKey`).
+*/
+function flatTableDependsOn(tableName) {
+	return [{
+		nodeKind: RelationalSchemaNodeKind.schema,
+		id: "database"
+	}, {
+		nodeKind: RelationalSchemaNodeKind.table,
+		id: tableName
+	}];
+}
+/**
+* The chains from a table-child object (foreign key, index, unique, primary
+* key) to each of the own columns it is built on — the introspection-side
+* mirror of `contractToSchemaIR`'s `flatColumnDependsOn`. An object is dropped
+* before the columns it covers.
+*/
+function flatColumnDependsOn(tableName, columns) {
+	return columns.map((column) => [...flatTableDependsOn(tableName), {
+		nodeKind: RelationalSchemaNodeKind.column,
+		id: `column:${column}`
+	}]);
+}
+function sqliteInlineLiteral(wire) {
+	if (wire === null) return "NULL";
+	if (typeof wire === "boolean") return wire ? "1" : "0";
+	if (typeof wire === "number") {
+		if (!Number.isFinite(wire)) throw structuredError("CONTRACT.DEFAULT_INVALID", `sqliteRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal`);
+		return String(wire);
+	}
+	if (typeof wire === "bigint") return String(wire);
+	if (wire instanceof Date) {
+		if (Number.isNaN(wire.getTime())) throw structuredError("CONTRACT.DEFAULT_INVALID", "sqliteRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal");
+		return `'${escapeLiteral(wire.toISOString())}'`;
+	}
+	if (typeof wire === "string") return `'${escapeLiteral(wire)}'`;
+	if (wire instanceof Uint8Array) return `X'${Array.from(wire).map((b) => b.toString(16).padStart(2, "0")).join("")}'`;
+	if (typeof wire === "object") return `'${escapeLiteral(JSON.stringify(wire))}'`;
+	throw structuredError("CONTRACT.PACK_CONTRIBUTION_INVALID", `sqliteRenderDdlExecuteRequest: unexpected wire type "${typeof wire}"`, { meta: { wireType: typeof wire } });
+}
+async function sqliteRenderDdlColumnDefault(def, codecLookup, codecRef) {
+	if (def.kind === "function") {
+		if (def.expression === "autoincrement()") return "";
+		if (def.expression === "now()") return "DEFAULT (datetime('now'))";
+		return `DEFAULT (${def.expression})`;
+	}
+	if (codecRef !== void 0) {
+		const codec = codecLookup.get(codecRef.codecId);
+		if (codec !== void 0) return `DEFAULT ${sqliteInlineLiteral(await codec.encode(def.value, {}))}`;
+	}
+	return `DEFAULT ${sqliteInlineLiteral(def.value)}`;
+}
+async function sqliteRenderDdlColumn(column, codecLookup) {
+	if (column.type.includes("AUTOINCREMENT")) return `${quoteIdentifier(column.name)} ${column.type}`;
+	const parts = [quoteIdentifier(column.name), column.type];
+	if (column.notNull) parts.push("NOT NULL");
+	if (column.primaryKey) parts.push("PRIMARY KEY");
+	if (column.default) {
+		const clause = await sqliteRenderDdlColumnDefault(column.default, codecLookup, column.codecRef);
+		if (clause.length > 0) parts.push(clause);
+	}
+	return parts.join(" ");
+}
+function sqliteRenderDdlConstraint(constraint) {
+	if (constraint.kind === "primary-key") {
+		const cols = constraint.columns.map(quoteIdentifier).join(", ");
+		if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} PRIMARY KEY (${cols})`;
+		return `PRIMARY KEY (${cols})`;
+	}
+	if (constraint.kind === "foreign-key") {
+		let sql = `FOREIGN KEY (${constraint.columns.map(quoteIdentifier).join(", ")}) REFERENCES ${constraint.refTable.split(".").map(quoteIdentifier).join(".")} (${constraint.refColumns.map(quoteIdentifier).join(", ")})`;
+		if (constraint.onDelete !== void 0) sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[constraint.onDelete]}`;
+		if (constraint.onUpdate !== void 0) sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[constraint.onUpdate]}`;
+		if (constraint.name !== void 0) sql = `CONSTRAINT ${quoteIdentifier(constraint.name)} ${sql}`;
+		return sql;
+	}
+	if (constraint.kind === "check-expression") throw structuredError("CONTRACT.CONSTRAINT_INVALID", `SQLite does not support expression CHECK constraints (constraint "${constraint.name}"). Scalar-array columns and their element-non-null checks are Postgres-only.`, { meta: { constraintName: constraint.name } });
+	const cols = constraint.columns.map(quoteIdentifier).join(", ");
+	if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
+	return `UNIQUE (${cols})`;
+}
+async function sqliteRenderDdlExecuteRequest(ast, codecLookup) {
+	const node = blindCast(ast);
+	const ifNotExists = node.ifNotExists ? "IF NOT EXISTS " : "";
+	const tableRef = quoteIdentifier(node.table);
+	const columnDefs = await Promise.all(node.columns.map((col) => sqliteRenderDdlColumn(col, codecLookup)));
+	const constraintDefs = node.constraints !== void 0 ? node.constraints.map(sqliteRenderDdlConstraint) : [];
+	return {
+		sql: `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${[...columnDefs, ...constraintDefs].join(",\n  ")}\n)`,
+		params: []
+	};
+}
+function nodeKind(value) {
+	if (typeof value === "object" && value !== null && "kind" in value && typeof value.kind === "string") return value.kind;
+	return "unknown";
+}
+function unreachableKind(value) {
+	return nodeKind(value);
+}
+const defaultCapabilities = Object.freeze({ sql: {
+	orderBy: true,
+	limit: true,
+	lateral: false,
+	jsonAgg: true,
+	returning: true,
+	enums: false
+} });
+var SqliteAdapterImpl = class {
+	familyId = "sql";
+	targetId = "sqlite";
+	profile;
+	#codecs;
+	constructor(codecRegistry, profileId) {
+		this.#codecs = codecRegistry;
+		const controlAdapter = new SqliteControlAdapter(codecRegistry);
+		this.profile = Object.freeze({
+			id: profileId ?? "sqlite/default@1",
+			target: "sqlite",
+			capabilities: defaultCapabilities,
+			readMarker: (queryable) => controlAdapter.readMarkerDiscriminated({
+				familyId: "sql",
+				targetId: "sqlite",
+				query: async (sql, params) => {
+					return { rows: [...(await queryable.query(sql, params)).rows] };
+				},
+				close: async () => {}
+			}, APP_SPACE_ID)
+		});
+	}
+	lower(ast, context) {
+		if (isDdlNode(ast)) throw structuredError("RUNTIME.DDL_UNSUPPORTED", "lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.", { meta: { surface: "runtime-adapter" } });
+		return renderLoweredSql(ast, context.contract, this.#codecs);
+	}
+};
+/** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a sqlite client. Contributed as the descriptor's static `rawCodecInferer` slot. */
+const sqliteRawCodecInferer = { inferCodec(value) {
+	switch (typeof value) {
+		case "number": return Number.isSafeInteger(value) && value % 1 === 0 ? "sqlite/integer@1" : "sqlite/real@1";
+		case "bigint": return "sqlite/bigint@1";
+		case "string": return "sqlite/text@1";
+		case "boolean": return "sqlite/integer@1";
+		case "object": if (value instanceof Uint8Array) return "sqlite/blob@1";
+	}
+	throw structuredError("RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION", "unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec", { meta: { valueType: typeof value } });
+} };
+/**
+* Lower a SQL query AST into a SQLite-flavored `{ sql, params }` payload.
+*
+* Shared between the runtime adapter (`SqliteAdapterImpl.lower`) and the control adapter (`SqliteControlAdapter.lower`) so both produce byte-identical SQL for the same AST and contract.
+*/
+function renderLoweredSql(ast, contract, codecs) {
+	const ctx = {
+		contract,
+		codecs
+	};
+	const collectedParamRefs = ast.collectParamRefs();
+	const params = [];
+	for (const ref of collectedParamRefs) params.push(ref.kind === "prepared-param-ref" ? {
+		kind: "bind",
+		name: ref.name
+	} : {
+		kind: "literal",
+		value: ref.value
+	});
+	let sql;
+	const node = ast;
+	switch (node.kind) {
+		case "select":
+			sql = renderSelect(node, ctx);
+			break;
+		case "insert":
+			sql = renderInsert(node, ctx);
+			break;
+		case "update":
+			sql = renderUpdate(node, ctx);
+			break;
+		case "delete":
+			sql = renderDelete(node, ctx);
+			break;
+		default: throw new InternalError(`Unsupported AST node kind: ${nodeKind(node)}`);
+	}
+	return Object.freeze({
+		sql,
+		params
+	});
+}
+function renderLimitOffset(keyword, value, ctx) {
+	if (value === void 0) return "";
+	if (typeof value === "number") return `${keyword} ${value}`;
+	return `${keyword} ${renderExpr(value, ctx)}`;
+}
+function renderSelect(ast, ctx) {
+	return [
+		`SELECT ${ast.distinct ? "DISTINCT " : ""}${renderProjection(ast.projection, ctx)}`,
+		ast.from !== void 0 ? `FROM ${renderSource(ast.from, ctx)}` : "",
+		ast.joins?.length ? ast.joins.map((join) => renderJoin(join, ctx)).join(" ") : "",
+		ast.where ? `WHERE ${renderExpr(ast.where, ctx)}` : "",
+		ast.groupBy?.length ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, ctx)).join(", ")}` : "",
+		ast.having ? `HAVING ${renderExpr(ast.having, ctx)}` : "",
+		ast.orderBy?.length ? `ORDER BY ${ast.orderBy.map((order) => `${renderExpr(order.expr, ctx)} ${order.dir.toUpperCase()}`).join(", ")}` : "",
+		renderLimitOffset("LIMIT", ast.limit, ctx),
+		renderLimitOffset("OFFSET", ast.offset, ctx)
+	].filter((part) => part.length > 0).join(" ").trim();
+}
+function renderProjection(projection, ctx) {
+	return projection.map((item) => {
+		const alias = quoteIdentifier(item.alias);
+		if (item.expr.kind === "literal") return `${renderLiteral(item.expr)} AS ${alias}`;
+		return `${renderExpr(item.expr, ctx)} AS ${alias}`;
+	}).join(", ");
+}
+function qualifyTableFromNamespaceCoordinate(table, ctx) {
+	if (table.namespaceId === void 0) return quoteIdentifier(table.name);
+	if (ctx.contract === void 0) throw new InternalError(`Table "${table.name}" carries namespace "${table.namespaceId}" but no contract was supplied to resolve it`);
+	const namespace = ctx.contract.storage.namespaces[table.namespaceId];
+	if (namespace === void 0) throw structuredError("RUNTIME.NAMESPACE_UNKNOWN", `Table "${table.name}" references namespace "${table.namespaceId}" which is not present on the contract`, { meta: {
+		table: table.name,
+		namespaceId: table.namespaceId,
+		reason: "not-present"
+	} });
+	const qualifyTable = namespace.qualifyTable;
+	if (qualifyTable === void 0) throw structuredError("RUNTIME.NAMESPACE_UNKNOWN", `Table "${table.name}" references namespace "${table.namespaceId}" which is not materialised for SQL rendering on the contract`, { meta: {
+		table: table.name,
+		namespaceId: table.namespaceId,
+		reason: "not-materialised"
+	} });
+	return qualifyTable.call(namespace, table.name);
+}
+function renderTableSource(source, ctx) {
+	const qualified = qualifyTableFromNamespaceCoordinate(source, ctx);
+	if (!source.alias) return qualified;
+	return `${qualified} AS ${quoteIdentifier(source.alias)}`;
+}
+function renderSource(source, ctx) {
+	const node = source;
+	switch (node.kind) {
+		case "table-source": return renderTableSource(node, ctx);
+		case "derived-table-source": return `(${renderSelect(node.query, ctx)}) AS ${quoteIdentifier(node.alias)}`;
+		case "function-source": {
+			if (node.ordinality) throw structuredError("ADAPTER.CAPABILITY_MISSING", "SQLite does not support WITH ORDINALITY on function sources", { meta: {
+				target: "sqlite",
+				feature: "function-source-with-ordinality"
+			} });
+			if (node.columnAliases !== void 0) throw structuredError("ADAPTER.CAPABILITY_MISSING", "SQLite does not support returned-column aliases on function sources", { meta: {
+				target: "sqlite",
+				feature: "function-source-column-aliases"
+			} });
+			const args = node.args.map((arg) => renderExpr(arg, ctx)).join(", ");
+			const call = `${node.fn}(${args})`;
+			return node.alias !== void 0 ? `${call} AS ${quoteIdentifier(node.alias)}` : call;
+		}
+		default: return assertNever(node, `Unsupported source node kind: ${unreachableKind(node)}`);
+	}
+}
+function renderExpr(expr, ctx) {
+	const node = expr;
+	switch (node.kind) {
+		case "column-ref": return renderColumn(node);
+		case "identifier-ref": return quoteIdentifier(node.name);
+		case "operation": return renderOperation(node, ctx);
+		case "subquery": return renderSubqueryExpr(node, ctx);
+		case "aggregate": return renderAggregateExpr(node, ctx);
+		case "window-func": return renderWindowFuncExpr(node, ctx);
+		case "function-call": return renderFunctionCallExpr(node, ctx);
+		case "cast": return renderCastExpr(node, ctx);
+		case "case": return renderCaseExpr(node, ctx);
+		case "json-object": return renderJsonObjectExpr(node, ctx);
+		case "json-array-agg": return renderJsonArrayAggExpr(node, ctx);
+		case "binary": return renderBinary(node, ctx);
+		case "and":
+			if (node.exprs.length === 0) return "TRUE";
+			return `(${node.exprs.map((part) => renderExpr(part, ctx)).join(" AND ")})`;
+		case "or":
+			if (node.exprs.length === 0) return "FALSE";
+			return `(${node.exprs.map((part) => renderExpr(part, ctx)).join(" OR ")})`;
+		case "exists":
+			if (ctx.contract === void 0) throw new InternalError("EXISTS subquery rendering requires a Sqlite contract");
+			return `${node.notExists ? "NOT " : ""}EXISTS (${renderSelect(node.subquery, ctx)})`;
+		case "null-check": return renderNullCheck(node, ctx);
+		case "not": return `NOT (${renderExpr(node.expr, ctx)})`;
+		case "param-ref":
+		case "prepared-param-ref": return "?";
+		case "literal": return renderLiteral(node);
+		case "list": return renderListLiteral(node, ctx);
+		case "raw-expr": return renderRawExpr(node, ctx);
+		default: return assertNever(node, `Unsupported expression node kind: ${unreachableKind(node)}`);
+	}
+}
+function renderRawExpr(node, ctx) {
+	return node.parts.map((part) => typeof part === "string" ? part : renderExpr(part, ctx)).join("");
+}
+function renderColumn(ref) {
+	if (ref.table === "excluded") return `excluded.${quoteIdentifier(ref.column)}`;
+	return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
+}
+function renderLiteral(expr) {
+	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
+	if (typeof expr.value === "number" || typeof expr.value === "boolean") return String(expr.value);
+	if (typeof expr.value === "bigint") return String(expr.value);
+	if (expr.value === null || expr.value === void 0) return "NULL";
+	if (expr.value instanceof Date) return `'${escapeLiteral(expr.value.toISOString())}'`;
+	const json = JSON.stringify(expr.value);
+	if (json === void 0) return "NULL";
+	return `'${escapeLiteral(json)}'`;
+}
+function renderOperation(expr, ctx) {
+	const self = renderExpr(expr.self, ctx);
+	const args = expr.args.map((arg) => renderExpr(arg, ctx));
+	let result = expr.lowering.template;
+	result = result.replace(/\{\{self\}\}/g, self);
+	for (let i = 0; i < args.length; i++) result = result.replace(new RegExp(`\\{\\{arg${i}\\}\\}`, "g"), args[i] ?? "");
+	return result;
+}
+function renderSubqueryExpr(expr, ctx) {
+	if (expr.query.projection.length !== 1) throw structuredError("RUNTIME.AST_INVALID", "Subquery expressions must project exactly one column", { meta: { node: "subquery" } });
+	if (ctx.contract === void 0) throw new InternalError("Subquery expression rendering requires a Sqlite contract");
+	return `(${renderSelect(expr.query, ctx)})`;
+}
+function requiresNullCheckGrouping(kind) {
+	switch (kind) {
+		case "operation":
+		case "subquery": return true;
+		case "column-ref":
+		case "identifier-ref":
+		case "aggregate":
+		case "window-func":
+		case "function-call":
+		case "cast":
+		case "case":
+		case "json-object":
+		case "json-array-agg":
+		case "binary":
+		case "and":
+		case "or":
+		case "exists":
+		case "null-check":
+		case "not":
+		case "param-ref":
+		case "prepared-param-ref":
+		case "literal":
+		case "list":
+		case "raw-expr": return false;
+	}
+}
+function renderNullCheck(expr, ctx) {
+	const rendered = renderExpr(expr.expr, ctx);
+	const renderedExpr = requiresNullCheckGrouping(expr.expr.kind) ? `(${rendered})` : rendered;
+	return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
+}
+function renderBinary(expr, ctx) {
+	if (expr.right.kind === "list" && expr.right.values.length === 0) {
+		if (expr.op === "in") return "FALSE";
+		if (expr.op === "notIn") return "TRUE";
+	}
+	const leftExpr = expr.left;
+	const left = renderExpr(leftExpr, ctx);
+	const leftRendered = leftExpr.kind === "operation" || leftExpr.kind === "subquery" ? `(${left})` : left;
+	const rightNode = expr.right;
+	let right;
+	switch (rightNode.kind) {
+		case "list":
+			right = renderListLiteral(rightNode, ctx);
+			break;
+		case "literal":
+			right = renderLiteral(rightNode);
+			break;
+		case "column-ref":
+			right = renderColumn(rightNode);
+			break;
+		case "param-ref":
+		case "prepared-param-ref":
+			right = "?";
+			break;
+		default:
+			right = renderExpr(rightNode, ctx);
+			break;
+	}
+	return `${leftRendered} ${{
+		eq: "=",
+		neq: "!=",
+		gt: ">",
+		lt: "<",
+		gte: ">=",
+		lte: "<=",
+		like: "LIKE",
+		in: "IN",
+		notIn: "NOT IN"
+	}[expr.op]} ${right}`;
+}
+function renderListLiteral(expr, ctx) {
+	if (expr.values.length === 0) return "(NULL)";
+	return `(${expr.values.map((v) => {
+		if (v.kind === "param-ref" || v.kind === "prepared-param-ref") return "?";
+		if (v.kind === "literal") return renderLiteral(v);
+		return renderExpr(v, ctx);
+	}).join(", ")})`;
+}
+function renderAggregateExpr(expr, ctx) {
+	const fn = expr.fn.toUpperCase();
+	if (!expr.expr) return `${fn}(*)`;
+	return `${fn}(${renderExpr(expr.expr, ctx)})`;
+}
+function renderWindowFuncExpr(expr, ctx) {
+	return `${expr.fn.toUpperCase()}(${expr.args.map((arg) => renderExpr(arg, ctx)).join(", ")}) OVER (${[expr.partitionBy && expr.partitionBy.length > 0 ? `PARTITION BY ${expr.partitionBy.map((e) => renderExpr(e, ctx)).join(", ")}` : "", expr.orderBy && expr.orderBy.length > 0 ? `ORDER BY ${renderOrderByItems(expr.orderBy, ctx)}` : ""].filter((part) => part.length > 0).join(" ")})`;
+}
+function renderFunctionCallExpr(expr, ctx) {
+	const args = expr.args.map((arg) => renderExpr(arg, ctx)).join(", ");
+	return `${expr.fn}(${args})`;
+}
+function renderCastExpr(expr, ctx) {
+	return `CAST(${renderExpr(expr.expr, ctx)} AS ${expr.targetType})`;
+}
+function renderCaseExpr(expr, ctx) {
+	return `CASE ${expr.branches.map((branch) => `WHEN ${renderExpr(branch.condition, ctx)} THEN ${renderExpr(branch.value, ctx)}`).join(" ")}${expr.elseExpr === void 0 ? "" : ` ELSE ${renderExpr(expr.elseExpr, ctx)}`} END`;
+}
+function renderJsonValueProjection(projection, ctx) {
+	return projection.accept({
+		codec: ({ value, codec }) => renderExpr(projectJsonThroughCodec(value, codec, ctx.codecs), ctx),
+		native: ({ value }) => renderExpr(value, ctx),
+		document: ({ value }) => renderExpr(jsonDocumentRetag(value), ctx)
+	});
+}
+function projectJsonThroughCodec(value, codec, codecs) {
+	const descriptor = codecs.descriptorFor(codec.codecId);
+	if (descriptor === void 0) throw structuredError("RUNTIME.PARAM_REF_MISSING_CODEC", `SQLite lowering: a JSON projection carries codecId "${codec.codecId}" but the validated SQLite codec registry has no entry for it. This usually indicates a missing extension pack in the runtime stack — register the pack that contributes this codec, or use the codec directly from \`@prisma/orm-target-sqlite/target/codecs\` if it's a builtin.`, { meta: { codecId: codec.codecId } });
+	return descriptor.projectJson(value, codec);
+}
+function renderJsonObjectExpr(expr, ctx) {
+	return `json_object(${expr.entries.flatMap((entry) => {
+		return [`'${escapeLiteral(entry.key)}'`, renderJsonValueProjection(entry.value, ctx)];
+	}).join(", ")})`;
+}
+function renderOrderByItems(items, ctx) {
+	return items.map((item) => `${renderExpr(item.expr, ctx)} ${item.dir.toUpperCase()}`).join(", ");
+}
+function renderJsonArrayAggExpr(expr, ctx) {
+	const aggregateOrderBy = expr.orderBy && expr.orderBy.length > 0 ? ` ORDER BY ${renderOrderByItems(expr.orderBy, ctx)}` : "";
+	const aggregated = `json_group_array(${renderJsonValueProjection(expr.expr, ctx)}${aggregateOrderBy})`;
+	if (expr.onEmpty === "emptyArray") return `coalesce(${aggregated}, '[]')`;
+	return aggregated;
+}
+function renderJoin(join, ctx) {
+	if (ctx.contract === void 0) throw new InternalError("JOIN rendering requires a Sqlite contract");
+	return `${join.joinType.toUpperCase()} JOIN ${renderSource(join.source, ctx)} ON ${renderJoinOn(join.on, ctx)}`;
+}
+function renderJoinOn(on, ctx) {
+	if (on.kind === "eq-col-join-on") return `${renderColumn(on.left)} = ${renderColumn(on.right)}`;
+	return renderExpr(on, ctx);
+}
+function renderInsertValue(value, ctx) {
+	switch (value.kind) {
+		case "param-ref":
+		case "prepared-param-ref": return "?";
+		case "column-ref": return renderColumn(value);
+		case "raw-expr": return renderExpr(value, ctx);
+		case "default-value": throw structuredError("RUNTIME.AST_UNSUPPORTED", "SQLite does not support DEFAULT as a value in INSERT ... VALUES", { meta: { node: "default-value" } });
+		default: return assertNever(value, `Unsupported value node in INSERT: ${unreachableKind(value)}`);
+	}
+}
+function renderInsert(ast, ctx) {
+	const table = qualifyTableFromNamespaceCoordinate(ast.table, ctx);
+	const rows = ast.rows;
+	const firstRow = rows[0];
+	if (firstRow === void 0) throw structuredError("RUNTIME.AST_INVALID", "INSERT requires at least one row", { meta: {
+		node: "insert",
+		table: ast.table.name
+	} });
+	const columnOrder = Object.keys(firstRow);
+	let insertClause;
+	if (columnOrder.length === 0) insertClause = `INSERT INTO ${table} DEFAULT VALUES`;
+	else {
+		const columns = columnOrder.map((column) => quoteIdentifier(column));
+		const values = rows.map((row) => {
+			return `(${columnOrder.map((column) => {
+				const value = row[column];
+				if (value === void 0) throw structuredError("RUNTIME.AST_INVALID", `Missing value for column "${column}" in INSERT row`, { meta: {
+					node: "insert",
+					table: ast.table.name,
+					column
+				} });
+				return renderInsertValue(value, ctx);
+			}).join(", ")})`;
+		}).join(", ");
+		insertClause = `INSERT INTO ${table} (${columns.join(", ")}) VALUES ${values}`;
+	}
+	let onConflictClause = "";
+	if (ast.onConflict) {
+		const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
+		if (conflictColumns.length === 0) throw structuredError("RUNTIME.AST_INVALID", "INSERT onConflict requires at least one conflict column", { meta: {
+			node: "insert",
+			table: ast.table.name
+		} });
+		const action = ast.onConflict.action;
+		switch (action.kind) {
+			case "do-nothing":
+				onConflictClause = ` ON CONFLICT (${conflictColumns.join(", ")}) DO NOTHING`;
+				break;
+			case "do-update-set": {
+				const updates = Object.entries(action.set).map(([colName, value]) => {
+					return `${quoteIdentifier(colName)} = ${renderExpr(value, ctx)}`;
+				});
+				onConflictClause = ` ON CONFLICT (${conflictColumns.join(", ")}) DO UPDATE SET ${updates.join(", ")}`;
+				break;
+			}
+			default: assertNever(action, `Unsupported onConflict action: ${unreachableKind(action)}`);
+		}
+	}
+	const returningClause = renderReturning(ast.returning, ctx);
+	return `${insertClause}${onConflictClause}${returningClause}`;
+}
+function renderUpdate(ast, ctx) {
+	const table = qualifyTableFromNamespaceCoordinate(ast.table, ctx);
+	const setClauses = Object.entries(ast.set).map(([col, val]) => {
+		return `${quoteIdentifier(col)} = ${renderExpr(val, ctx)}`;
+	});
+	const whereClause = ast.where ? ` WHERE ${renderExpr(ast.where, ctx)}` : "";
+	const returningClause = renderReturning(ast.returning, ctx);
+	return `UPDATE ${table} SET ${setClauses.join(", ")}${whereClause}${returningClause}`;
+}
+function renderDelete(ast, ctx) {
+	return `DELETE FROM ${qualifyTableFromNamespaceCoordinate(ast.table, ctx)}${ast.where ? ` WHERE ${renderExpr(ast.where, ctx)}` : ""}${renderReturning(ast.returning, ctx)}`;
+}
+function renderReturning(returning, ctx) {
+	if (!returning?.length) return "";
+	return ` RETURNING ${returning.map((item) => {
+		if (item.expr.kind === "column-ref") {
+			const rendered = `${quoteIdentifier(item.expr.table)}.${quoteIdentifier(item.expr.column)}`;
+			return item.expr.column === item.alias ? rendered : `${rendered} AS ${quoteIdentifier(item.alias)}`;
+		}
+		return `${renderExpr(item.expr, ctx)} AS ${quoteIdentifier(item.alias)}`;
+	}).join(", ")}`;
+}
+function createSqliteAdapter(options) {
+	const codecRegistry = createSqliteCodecRegistryWithBuiltins(options?.codecDescriptors);
+	return Object.freeze(new SqliteAdapterImpl(codecRegistry, options?.profileId));
+}
+function createSqliteAdapterWithCodecRegistry(codecRegistry) {
+	return Object.freeze(new SqliteAdapterImpl(codecRegistry));
+}
+//#endregion
+export { createSqliteBuiltinCodecLookup as a, createSqliteAdapterWithCodecRegistry as i, assembleSqliteCodecRegistry as n, createSqliteCodecRegistryWithBuiltins as o, createSqliteAdapter as r, sqliteRawCodecInferer as s, SqliteControlAdapter as t };
+
+//# sourceMappingURL=adapter-wc9p_v2Z-y8pzqMfG.mjs.map