@voltro/sql-sqlite 0.48.0 → 0.49.0

package/CHANGELOG.md

@@ -39,6 +39,73 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.49.0] — 2026-08-23
+
+### ⚠ BREAKING
+
+- **@voltro/cli, @voltro/data-transfer, @voltro/database, @voltro/sql-sqlite, @voltro/voltro** — A data transfer is a series of short requests now — no single one may outlive a caller's budget.
+
+  **The rule:** *a request that carries bytes never runs a transfer; a request that starts a transfer never carries bytes.* It was broken in the worst available place. The upload was already chunked and resumable — many short requests, each abandonable — and then the FINAL chunk fell through and ran the whole import. So the longest request of the flow arrived AFTER the entire upload had succeeded, and a caller under a policy that caps a single request (a job runner that kills a client at ten minutes; a 30 s ingress ceiling) lost the most expensive thing they had already paid for. A single-request upload had the same shape without the excuse, and the export had no protocol at all: one request that read the whole database and streamed it back.
+
+  **Import.** `POST /_voltro/admin/import` accumulates and answers `202`. `POST /_voltro/admin/import/start` begins the run and answers `202 { runId }` as soon as the run's first row exists. `start` is idempotent per upload — it is a short request and therefore a retryable one, and without a claim a retry would begin a second destructive run from the same bytes. A claim whose run has ENDED is taken over rather than honoured forever, so a process that dies holding one cannot poison a bundle.
+
+  **Export.** `POST /_voltro/admin/export` answers `202 { runId }` and produces in the background; the bytes come back from `GET /_voltro/admin/export/download?runId=&offset=&length=` in ranges, resumable, with the total in a header. Object storage (`--bundle-key`) remains for a bundle you want to KEEP — it is no longer the only way to get one out, because requiring it would leave an instance without storage unable to export at all.
+
+  **The client.** `--max-request-seconds` (or `VOLTRO_MAX_REQUEST_SECONDS`) declares the budget — declared rather than probed, because the thing that kills a request is a policy on the caller's side and only they know it. `--detach` returns once the run has started and says the outcome is NOT known. Attached, the CLI polls the record and prints per-table progress; Ctrl-C then loses the watching and never the run.
+
+  **The trap, stated because it is the one way to get this wrong:** a failure used to arrive in the response (409 on drift, 409 on a refused mode, 500 otherwise). After the split the response is a `202`, so **a client deriving its exit code from the status line reports a failed import as a success.** The exit code comes from the polled record, in one shared function, and the drift check moved into `start` where it can still be a refusal that leaves no history.
+
+  **Two knobs that were constants.** `VOLTRO_IMPORT_UPLOAD_DIR` and `VOLTRO_EXPORT_ARTIFACT_DIR` move the staging areas off the default temp filesystem — which on a container is frequently a small tmpfs, so an instance simply could not accept a bundle the size a grown database produces, and the failure arrived as a write error halfway through an upload somebody had been waiting on.
+
+  **Renamed:** `voltro data imports` → `voltro data transfers`, and `_voltro_data_imports` → `_voltro_data_transfers` with a `direction` column. The command showed one direction and now shows both; the table rename carries its rows via the declarative differ on every dialect and needs nothing from you. The CLI rename ships a `manual` codemod — the command lives in scripts, CI jobs and runbooks, which `voltro update` cannot see or rewrite. The four PUBLIC exports that named the same record were renamed with it (`ImportRun`, `describeImportRun`, `IMPORT_RUNS_TABLE`, `_voltroImportRunsTable`); those are application source, they ship their own `transform` codemod, and they have their own entry.
+- **@voltro/database, @voltro/voltro** — The run-history exports say `transfer`, not `import`.
+
+  `@voltro/database` (and `voltro/database`) renamed four public exports along with the table behind them:
+
+  | was | is | |---|---| | `ImportRun` | `DataTransferRun` | | `describeImportRun` | `describeTransferRun` | | `IMPORT_RUNS_TABLE` | `DATA_TRANSFERS_TABLE` | | `_voltroImportRunsTable` | `_voltroDataTransfersTable` |
+
+  An EXPORT writes to this record now — the row carries a `direction` — so every one of those names described half of what it holds.
+
+  A `transform` codemod rewrites all four, alias-aware, from either module spelling. It also rewrites a hand-spelled `_voltro_data_imports` in a string, template or raw-SQL fragment, and that is the half worth stating: the four identifiers announce themselves as compile errors, while a query that addresses the table by name has nothing to fail on. The table itself moves with its rows via the declarative differ on every dialect.
+
+  This is filed apart from the transfer-protocol entry beside it deliberately. That one's codemod is `manual` and is about a CLI invocation living in scripts and CI jobs; this one is application source and is rewritten for you. Reading the first as covering both is what would leave a build broken with a note saying nothing in your source was affected.
+
+### Added
+
+- **@voltro/database, @voltro/data-transfer, @voltro/cli** — An import records WHETHER it staged, and a soft-dropped column says so in a drift refusal.
+
+  **`_voltro_data_imports.staged`.** The pre-upload preflight says what the instance WILL do; the run's own line says what it did — and that line is printed inside the instance, which is exactly where an operator using `--target api` cannot read it. So "we were told it would stage" and "it staged" were two claims with no way to close the gap between them from outside. The column is `null` for a mode where the question does not arise; `voltro data imports` and `GET /_voltro/admin/imports` both carry it.
+
+  **A soft-dropped column is named as one.** `<original>__dropped_<stamp>` is what the differ leaves behind when an app stops declaring a column — only the database that did the drop has it, so it drifts against every target. The refusal reported it as an ordinary missing column ("the value has nowhere to go"), which points at the TARGET's schema: the one place the fix does not lie. It now says where the column lives and how to reclaim it.
+
+### Fixed
+
+- **@voltro/data-transfer, @voltro/sql-sqlite, @voltro/database** — A successful `--mode replace --no-atomic` left a marker that refused the next boot.
+
+  Two defects, one visible symptom, and both were silent by construction.
+
+  **The clear was gated on the WRITE's condition.** `!(useLedger && ledger.truncated)` means "an earlier attempt already recorded this destructive run, do not write a second row" — correct on the write. Copied down to the clear its meaning inverts: `ledger.truncated` is set by the emptying step of THIS run, so on `--no-atomic` (the only mode where `useLedger` is true) the clear was skipped by the very run that wrote the marker.
+
+  **And a `Date` in a predicate is not bindable on sqlite.** `better-sqlite3` binds numbers, strings, bigints, buffers and null; the row path has coerced Dates since that store was written, and the eager-join compiler carried its own private copy of the fix, but `query` / `updateMany` / `deleteMany` bound the raw value. So every comparison of a timestamp column against a `Date` failed with `Failed to execute statement` — including the marker's clear, which swallows its errors ON PURPOSE (a store with no marker table must not fail an import over a bookkeeping row) and therefore said nothing. The retention sweep compares `lt(column, cutoff)` the same way.
+
+  Together: a fully successful replace left the marker standing, and the next boot REFUSED with "a destructive import did not finish" over a database that was completely fine. The one recovery is a command the operator has no reason to think they need. It stayed invisible because `atomic` defaults to true for `replace`, and because a staged replace writes no marker at all — two defaults hiding the one mode that exists for large, interruptible loads.
+
+  The coercion is shared now and applied at all three predicate sites, with a guard that fails on a fourth that forgets. A dry run also closes its trace row: a preview that finished instantly used to leave the record open, so a polling caller waited out its whole budget over a run that was long done.
+- **@voltro/cli** — `voltro codegen` declared twenty framework tables fewer than a boot.
+
+  The app half of this was fixed last release and looked like the whole thing. It was not: `codegen` derived the FEATURE MIX from the file list it had just walked, and that list is the entity/relations set — which contains no `*.workflow.tsx`, no `*.agent.ts`, no `*.cron.tsx`. So every feature flag came back false, and the dialect was never passed at all, taking `_voltro_cdc_offsets` with it. Measured on an app with two workflow files: 18 framework tables where the shared assembly produces 33.
+
+  It calls `assembleFrameworkTables({ root })` now — the same entry `voltro db plan/apply` uses, which detects the mix from the root rather than being handed one.
+
+  The parity guard moved with it. Comparing the two WALKS could not see this: both walks were right about files, and the divergence was introduced one layer past them. It compares the assembled SETS now, and runs codegen's own table function on a tree whose only feature signals are a workflow file and an agent file — a source assertion that the right function is CALLED cannot see a wrong argument handed to it, and a wrong argument is what this was.
+- **@voltro/cli** — `voltro data --help` advertised four subcommands out of nine.
+
+  It printed `<export|import|backup|restore>` while the command dispatched those four plus `imports`, `inspect`, `unpack`, `clear-replace-marker` and `clear-staging`. A quoted enumeration is read as exhaustive — the same failure `subcommandNames.ts` was written for after a `db` list cost two wrong conclusions — and the missing entry here is the one that answers "what is my import doing right now" for somebody who cannot reach the pod.
+
+  `subcommandHelpParity.test.ts` had listed `data` among the commands it could not check, loudly and correctly: there was no name list to check against. There is one now (`DATA_SUBCOMMANDS`), the dispatch is a keyed `Record`, so a subcommand with no name and a name with no handler are both compile errors, and the usage line is generated from the same array. `data` is out of the unchecked list.
+
+---
+
 ## [0.48.0] — 2026-08-22
 
 ### Added

package/dist/index.js

@@ -3,12 +3,12 @@ import { Config as t, Context as n, Effect as r, Layer as i, ManagedRuntime as a
 import { EventEmitter as s } from "node:events";
 import { createLogger as c } from "@voltro/logger";
 import { SqlClient as l, TransactionConnection as u } from "@effect/sql/SqlClient";
-import { EagerCardinalityError as d, attachEagerLoads as f, attributionFields as p, bulkInsertLimitsFor as m, chunkRowsForInsert as h, compileEagerJson as g, compilePredicate as _, compileRawFragment as v, compileSelect as y, decodeRowsFromSchema as b, externalChangeEvent as x, hasEagerLoads as S, isTableReactive as C, makeEagerFallbackReporter as w, observeDbOp as T, qualifyTable as E, quoteIdent as D, raiseChangeListenerCeiling as O, recordsTable as k, requireTable as A, runStoreTransaction as j, runWriteRecorders as M, stampGeneratedId as N, stampGeneratedIds as P, withCapturedAttribution as F } from "@voltro/database";
+import { EagerCardinalityError as d, attachEagerLoads as f, attributionFields as p, bulkInsertLimitsFor as m, chunkRowsForInsert as h, coercePredicateForSqlite as g, compileEagerJson as _, compilePredicate as v, compileRawFragment as y, compileSelect as b, decodeRowsFromSchema as x, externalChangeEvent as S, hasEagerLoads as C, isTableReactive as w, makeEagerFallbackReporter as T, observeDbOp as E, qualifyTable as D, quoteIdent as O, raiseChangeListenerCeiling as k, recordsTable as A, requireTable as j, runStoreTransaction as M, runWriteRecorders as N, stampGeneratedId as P, stampGeneratedIds as F, withCapturedAttribution as I } from "@voltro/database";
 //#region src/sqlLayer.ts
-var I = (r) => e.layerConfig({
+var L = (r) => e.layerConfig({
 	filename: t.succeed(r.filename),
 	...r.readonly === void 0 ? {} : { readonly: t.succeed(r.readonly) }
-}).pipe(i.tap((t) => n.get(t, e.SqliteClient)`PRAGMA foreign_keys = ON`)), L = (e) => {
+}).pipe(i.tap((t) => n.get(t, e.SqliteClient)`PRAGMA foreign_keys = ON`)), R = (e) => {
 	if (e.url) {
 		if (e.url === ":memory:") return { filename: ":memory:" };
 		if (e.url.startsWith("file:")) return { filename: e.url.slice(5) };
@@ -16,12 +16,12 @@ var I = (r) => e.layerConfig({
 	}
 	if (e.database) return { filename: e.database };
 	throw Error("@voltro/sql-sqlite: no filename supplied. Set DB_URL=file:./db.sqlite or DB_DATABASE=path/to/db.sqlite.");
-}, R = (e) => I(L(e)), z = /* @__PURE__ */ new Set([
+}, z = (e) => L(R(e)), B = /* @__PURE__ */ new Set([
 	"SQLITE_BUSY",
 	"SQLITE_LOCKED",
 	"5",
 	"6"
-]), B = (e) => {
+]), V = (e) => {
 	let t = e;
 	for (let e = 0; e < 5 && typeof t == "object" && t; e++) {
 		let e = t.code;
@@ -29,18 +29,21 @@ var I = (r) => e.layerConfig({
 		if (typeof e == "number") return String(e);
 		t = t.cause;
 	}
-}, V = (e) => {
-	let t = B(e);
-	return t !== void 0 && z.has(t);
-}, H = (e) => V(e) ? "retry" : "noRetry", U = c({ scope: "voltro:sqlite" }), W = async (e) => {
+}, H = (e) => {
+	let t = V(e);
+	return t !== void 0 && B.has(t);
+}, U = (e) => H(e) ? "retry" : "noRetry", W = c({ scope: "voltro:sqlite" }), G = async (e) => {
 	let t = e.tracerLayer ? i.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, n = a.make(t);
-	return new q(await n.runPromise(l), n, null, void 0, e.isRetryable ?? V, e.systemName ?? "sqlite", e.wrapTransaction);
-}, G = (e) => e, K = (e) => {
+	return new X(await n.runPromise(l), n, null, void 0, e.isRetryable ?? H, e.systemName ?? "sqlite", e.wrapTransaction);
+}, K = (e) => e, q = (e) => g(e), J = (e) => e.predicate === void 0 || e.predicate === null ? e : {
+	...e,
+	predicate: q(e.predicate)
+}, Y = (e) => {
 	if (typeof e != "object" || !e) return e;
 	let t = {};
 	for (let [n, r] of Object.entries(e)) t[n] = r instanceof Date ? r.toISOString() : typeof r == "boolean" ? +!!r : r;
 	return t;
-}, q = class e {
+}, X = class e {
 	sql;
 	runtime;
 	namespace;
@@ -50,26 +53,26 @@ var I = (r) => e.layerConfig({
 	emitter;
 	inflightTxns = 0;
 	reportEagerFallback;
-	constructor(e, t, n = null, r, i = V, a = "sqlite", o = G) {
-		this.sql = e, this.runtime = t, this.namespace = n, this.isRetryable = i, this.systemName = a, this.wrapTransaction = o, this.emitter = r ?? new s(), O(this.emitter), this.reportEagerFallback = w(U);
+	constructor(e, t, n = null, r, i = H, a = "sqlite", o = K) {
+		this.sql = e, this.runtime = t, this.namespace = n, this.isRetryable = i, this.systemName = a, this.wrapTransaction = o, this.emitter = r ?? new s(), k(this.emitter), this.reportEagerFallback = T(W);
 	}
 	withNamespace(t) {
 		return t === this.namespace ? this : new e(this.sql, this.runtime, t, this.emitter, this.isRetryable, this.systemName, this.wrapTransaction);
 	}
 	nsT(e) {
-		return E(this.namespace, e);
+		return D(this.namespace, e);
 	}
 	async attachNamespace(e, t) {
 		let n = this.sql, r = t ?? `${e}.db`;
 		await this.runtime.runPromise(n`ATTACH DATABASE ${r} AS ${n(e)}`);
 	}
 	async executeQuery(e, t, n) {
-		let i = y(e, this.sql, this.namespace), a = t ? r.provideService(i, u, t) : i, o = await T(this.systemName, "select", () => this.runtime.runPromise(a));
-		return b(o, e.table, "sqlite");
+		let i = b(J(e), this.sql, this.namespace), a = t ? r.provideService(i, u, t) : i, o = await E(this.systemName, "select", () => this.runtime.runPromise(a));
+		return x(o, e.table, "sqlite");
 	}
 	async executeInsert(e, t, n, i, a) {
-		t = N(e, t);
-		let o = this.sql, s = o`INSERT INTO ${o(this.nsT(e))} ${o.insert(K(t))} RETURNING *`, c = n ? r.provideService(s, u, n) : s, l = (await this.runtime.runPromise(c))[0];
+		t = P(e, t);
+		let o = this.sql, s = o`INSERT INTO ${o(this.nsT(e))} ${o.insert(Y(t))} RETURNING *`, c = n ? r.provideService(s, u, n) : s, l = (await this.runtime.runPromise(c))[0];
 		if (!l) throw Error(`SqliteStore.insert: no row returned for table '${e}'`);
 		return await this.routeEvent({
 			table: e,
@@ -79,7 +82,7 @@ var I = (r) => e.layerConfig({
 		}, i, n, a), l;
 	}
 	async executeUpdate(e, t, n, i, a, o) {
-		let s = this.sql, c = s`UPDATE ${s(this.nsT(e))} SET ${s.update(K(n))} WHERE ${s("id")} = ${t} RETURNING *`, l = i ? r.provideService(c, u, i) : c, d = (await this.runtime.runPromise(l))[0];
+		let s = this.sql, c = s`UPDATE ${s(this.nsT(e))} SET ${s.update(Y(n))} WHERE ${s("id")} = ${t} RETURNING *`, l = i ? r.provideService(c, u, i) : c, d = (await this.runtime.runPromise(l))[0];
 		return d ? (await this.routeEvent({
 			table: e,
 			op: "update",
@@ -88,8 +91,8 @@ var I = (r) => e.layerConfig({
 		}, a, i, o), d) : null;
 	}
 	async executeInsertMany(e, t, n, i, a) {
-		if (t = P(e, t), t.length === 0) return [];
-		let o = this.sql, s = t.map((e) => K(e)), c = h(s, m("sqlite")), l = (t) => o`INSERT INTO ${o(this.nsT(e))} ${o.insert(t)} RETURNING *`, d;
+		if (t = F(e, t), t.length === 0) return [];
+		let o = this.sql, s = t.map((e) => Y(e)), c = h(s, m("sqlite")), l = (t) => o`INSERT INTO ${o(this.nsT(e))} ${o.insert(t)} RETURNING *`, d;
 		if (c.length === 1) {
 			let e = l(c[0]), t = n ? r.provideService(e, u, n) : e;
 			d = await this.runtime.runPromise(t);
@@ -125,7 +128,7 @@ var I = (r) => e.layerConfig({
 		}, i, n, a), !0) : !1;
 	}
 	async appendInTxn(e, t, n) {
-		let i = this.sql, a = i`INSERT INTO ${i(this.nsT(e))} ${i.insert(K(t))}`;
+		let i = this.sql, a = i`INSERT INTO ${i(this.nsT(e))} ${i.insert(Y(t))}`;
 		await this.runtime.runPromise(n ? r.provideService(a, u, n) : a);
 	}
 	async maxInTxn(e, t, n, i) {
@@ -136,7 +139,7 @@ var I = (r) => e.layerConfig({
 		e = {
 			...p(r),
 			...e
-		}, k(e.table) && await M({
+		}, A(e.table) && await N({
 			append: (e, t) => this.appendInTxn(e, t, n),
 			maxOf: (e, t, r) => this.maxInTxn(e, t, r, n)
 		}, {
@@ -146,14 +149,14 @@ var I = (r) => e.layerConfig({
 			prev: e.old,
 			traceId: e.traceId,
 			subjectId: e.subjectId
-		}), C(e.table) && (t === null ? this.emitter.emit("change", e) : t.push(e));
+		}), w(e.table) && (t === null ? this.emitter.emit("change", e) : t.push(e));
 	}
 	async executeUpsert(e, t, n, i, a, o) {
 		if (typeof n.update == "function") {
 			let r = await this.findByConflict(e, t, n.conflictColumns, i);
 			return r ? await this.executeUpdate(e, r.id, n.update(r), i, a) ?? r : this.executeInsert(e, t, i, a);
 		}
-		let s = this.sql, c = n.conflictColumns.map((e) => s`${s(e)}`), l = Object.keys(t).filter((e) => t[e] !== void 0), d = n.update === void 0 ? l.filter((e) => e !== "id" && !n.conflictColumns.includes(e)) : n.update, f = d.length > 0 ? s.csv(d.map((e) => s`${s(e)} = excluded.${s(e)}`)) : s`${s(n.conflictColumns[0])} = excluded.${s(n.conflictColumns[0])}`, p = s`INSERT INTO ${s(this.nsT(e))} ${s.insert(K(t))} ON CONFLICT (${s.csv(c)}) DO UPDATE SET ${f} RETURNING *`, m = i ? r.provideService(p, u, i) : p, h = (await this.runtime.runPromise(m))[0];
+		let s = this.sql, c = n.conflictColumns.map((e) => s`${s(e)}`), l = Object.keys(t).filter((e) => t[e] !== void 0), d = n.update === void 0 ? l.filter((e) => e !== "id" && !n.conflictColumns.includes(e)) : n.update, f = d.length > 0 ? s.csv(d.map((e) => s`${s(e)} = excluded.${s(e)}`)) : s`${s(n.conflictColumns[0])} = excluded.${s(n.conflictColumns[0])}`, p = s`INSERT INTO ${s(this.nsT(e))} ${s.insert(Y(t))} ON CONFLICT (${s.csv(c)}) DO UPDATE SET ${f} RETURNING *`, m = i ? r.provideService(p, u, i) : p, h = (await this.runtime.runPromise(m))[0];
 		if (!h) throw Error(`SqliteStore.upsert: no row returned for table '${e}'`);
 		let g = t.id !== void 0 && t.id === h.id ? "insert" : "update";
 		return await this.routeEvent({
@@ -164,8 +167,8 @@ var I = (r) => e.layerConfig({
 		}, a, i, o), h;
 	}
 	async executeInsertIgnore(e, t, n, i, a, o) {
-		t = N(e, t);
-		let s = this.sql, c = n.conflictColumns.map((e) => s`${s(e)}`), l = s`INSERT INTO ${s(this.nsT(e))} ${s.insert(K(t))} ON CONFLICT (${s.csv(c)}) DO NOTHING RETURNING *`, d = i ? r.provideService(l, u, i) : l, f = (await this.runtime.runPromise(d))[0];
+		t = P(e, t);
+		let s = this.sql, c = n.conflictColumns.map((e) => s`${s(e)}`), l = s`INSERT INTO ${s(this.nsT(e))} ${s.insert(Y(t))} ON CONFLICT (${s.csv(c)}) DO NOTHING RETURNING *`, d = i ? r.provideService(l, u, i) : l, f = (await this.runtime.runPromise(d))[0];
 		if (f) return await this.routeEvent({
 			table: e,
 			op: "insert",
@@ -185,14 +188,14 @@ var I = (r) => e.layerConfig({
 		return this.runWithEager(e, null);
 	}
 	raw(e, t) {
-		let n = v(e, this.sql);
-		return T(this.systemName, "raw", () => this.runtime.runPromise(n));
+		let n = y(e, this.sql);
+		return E(this.systemName, "raw", () => this.runtime.runPromise(n));
 	}
 	async runWithEager(e, t) {
-		if (!S(e)) return this.executeQuery(e, t);
-		let n = this.namespace === null ? g(e, this.sql, "sqlite") : null;
+		if (!C(e)) return this.executeQuery(e, t);
+		let n = this.namespace === null ? _(e, this.sql, "sqlite") : null;
 		if (n !== null) try {
-			let e = t ? r.provideService(n.fragment, u, t) : n.fragment, i = await T(this.systemName, "select", () => this.runtime.runPromise(e));
+			let e = t ? r.provideService(n.fragment, u, t) : n.fragment, i = await E(this.systemName, "select", () => this.runtime.runPromise(e));
 			return n.decode(i);
 		} catch (t) {
 			if (t instanceof d) throw t;
@@ -209,14 +212,14 @@ var I = (r) => e.layerConfig({
 			reason: "not-compilable"
 		});
 		let i = await this.executeQuery(e, t);
-		return f(i, e.eager, e.sourceTable ?? A(e.table), (e) => this.executeQuery(e, t));
+		return f(i, e.eager, e.sourceTable ?? j(e.table), (e) => this.executeQuery(e, t));
 	}
 	getInternalRunWithEager() {
 		return (e, t) => this.runWithEager(e, t);
 	}
 	localWrite(e, t, n) {
-		let r = (e) => k(t) ? this.writeWithRecorders(n, e) : n(e, null, null);
-		return T(this.systemName, e, () => F(r));
+		let r = (e) => A(t) ? this.writeWithRecorders(n, e) : n(e, null, null);
+		return E(this.systemName, e, () => I(r));
 	}
 	async writeWithRecorders(e, t) {
 		let n = [], i = this.sql, a = await this.runtime.runPromise(i.withTransaction(r.flatMap(r.serviceOption(u), (i) => o.isNone(i) ? r.fail(/* @__PURE__ */ Error("SqliteStore.write: TransactionConnection missing.")) : r.tryPromise({
@@ -242,7 +245,7 @@ var I = (r) => e.layerConfig({
 		return this.localWrite("delete", e, (n, r, i) => this.executeDelete(e, t, r, i, n));
 	}
 	async updateMany(e, t, n) {
-		let r = this.sql, i = _(n.where, r, this.namespace), a = r`UPDATE ${r(this.nsT(e))} SET ${r.update(K(t))} WHERE ${i} RETURNING *`, o = await T(this.systemName, "update", () => this.runtime.runPromise(a));
+		let r = this.sql, i = v(q(n.where), r, this.namespace), a = r`UPDATE ${r(this.nsT(e))} SET ${r.update(Y(t))} WHERE ${i} RETURNING *`, o = await E(this.systemName, "update", () => this.runtime.runPromise(a));
 		for (let t of o) await this.routeEvent({
 			table: e,
 			op: "update",
@@ -252,7 +255,7 @@ var I = (r) => e.layerConfig({
 		return o.length;
 	}
 	async deleteMany(e, t) {
-		let n = this.sql, r = _(t.where, n, this.namespace), i = n`DELETE FROM ${n(this.nsT(e))} WHERE ${r} RETURNING *`, a = await T(this.systemName, "delete", () => this.runtime.runPromise(i));
+		let n = this.sql, r = v(q(t.where), n, this.namespace), i = n`DELETE FROM ${n(this.nsT(e))} WHERE ${r} RETURNING *`, a = await E(this.systemName, "delete", () => this.runtime.runPromise(i));
 		for (let t of a) await this.routeEvent({
 			table: e,
 			op: "delete",
@@ -302,7 +305,7 @@ var I = (r) => e.layerConfig({
 		let t = this.sql, n = new Set(e), r = await this.runtime.runPromise(t`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`), i = [];
 		for (let e of r) {
 			if (n.has(e.name)) continue;
-			let r = await this.runtime.runPromise(t`${t.unsafe(`PRAGMA foreign_key_list(${D(e.name, "sqlite")})`)}`).catch(() => []);
+			let r = await this.runtime.runPromise(t`${t.unsafe(`PRAGMA foreign_key_list(${O(e.name, "sqlite")})`)}`).catch(() => []);
 			for (let t of r) n.has(t.table) && i.push({
 				from: e.name,
 				column: t.from,
@@ -319,10 +322,10 @@ var I = (r) => e.layerConfig({
 	async transactional(e) {
 		this.inflightTxns++;
 		try {
-			return await j({
+			return await M({
 				...this.txnSpec("SqliteStore.transactional"),
 				work: e,
-				makeView: (e, t) => new J(this, e, t)
+				makeView: (e, t) => new Z(this, e, t)
 			});
 		} finally {
 			this.inflightTxns--;
@@ -351,7 +354,7 @@ var I = (r) => e.layerConfig({
 		};
 	}
 	injectExternalChange(e) {
-		C(e.table) && this.emitter.emit("change", x(e));
+		w(e.table) && this.emitter.emit("change", S(e));
 	}
 	run(e) {
 		return this.runtime.runPromise(e);
@@ -360,7 +363,7 @@ var I = (r) => e.layerConfig({
 		if (this.inflightTxns > 0) {
 			let t = Date.now() + e;
 			for (; this.inflightTxns > 0 && Date.now() < t;) await new Promise((e) => setTimeout(e, 25));
-			this.inflightTxns > 0 && U.warn("close: grace period expired with in-flight transactions", {
+			this.inflightTxns > 0 && W.warn("close: grace period expired with in-flight transactions", {
 				gracePeriodMs: e,
 				inflight: this.inflightTxns
 			});
@@ -370,7 +373,7 @@ var I = (r) => e.layerConfig({
 	async ping() {
 		await this.runtime.runPromise(this.sql`SELECT 1`);
 	}
-}, J = class {
+}, Z = class {
 	parent;
 	txn;
 	attr;
@@ -446,12 +449,12 @@ var I = (r) => e.layerConfig({
 			this.events.length = 0;
 		}
 	}
-}, Y = {
+}, Q = {
 	id: "sqlite",
-	makeSqlLayer: (e) => R(e),
-	makeStore: (e) => W(e),
+	makeSqlLayer: (e) => z(e),
+	makeStore: (e) => G(e),
 	compileContains: (e, t, n) => n`${e} LIKE ${`%${t.replace(/[\\%_]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
-	retryFilter: H
+	retryFilter: U
 };
 //#endregion
-export { e as SqliteClient, L as connectionFromConfig, I as makeSqliteSqlLayer, R as makeSqliteSqlLayerFromConfig, W as makeSqliteStore, Y as sqliteDialect, H as sqliteRetryFilter };
+export { e as SqliteClient, R as connectionFromConfig, L as makeSqliteSqlLayer, z as makeSqliteSqlLayerFromConfig, G as makeSqliteStore, Q as sqliteDialect, U as sqliteRetryFilter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/sql-sqlite",
-  "version": "0.48.0",
+  "version": "0.49.0",
   "description": "SQLite dialect adapter for Voltro's cross-dialect DataStore (single-process; in-process change events).",
   "keywords": [
     "voltro",
@@ -35,8 +35,8 @@
   "dependencies": {
     "@effect/sql": "^0.52.0",
     "@effect/sql-sqlite-node": "^0.53.0",
-    "@voltro/database": "0.48.0",
-    "@voltro/logger": "0.48.0"
+    "@voltro/database": "0.49.0",
+    "@voltro/logger": "0.49.0"
   },
   "peerDependencies": {
     "effect": "^3.22.0"