@camstack/system 1.2.317 → 1.2.319

package/dist/wal-checkpoint-policy-d2z2qPqx.js

@@ -0,0 +1,233 @@
+//#region src/builtins/sqlite-storage/wal-checkpoint-policy.ts
+/**
+* When the checkpoint worker folds the WAL — the judgement, pure.
+*
+* ## Why a worker checkpoints at all
+*
+* `hub/sqlite-settings` is one JS thread with a synchronous binding, and every
+* configuration read in the cluster queues behind whatever statement it is
+* inside. With `journal_mode = WAL` and the build default `synchronous =
+* NORMAL`, an ordinary commit is an append to the WAL with NO fsync. The
+* fsyncs — the only thing in a one-row write that can take seconds — happen
+* at the CHECKPOINT: the WAL is synced before the pages are copied, the
+* database file after. And SQLite runs the auto-checkpoint (1000 pages)
+* INSIDE the commit of whichever writer crosses the threshold.
+*
+* Measured on the hub, 2026-09-11 10:45–10:55 CEST, from outside the process
+* (`/proc/<pid>/syscall` at 10 Hz + the wal-index header at 1 Hz, D452): the
+* WAL refilled at ~54 frames/s, the auto-checkpoint fired every 12–25 s (42
+* in 9.5 min), and every D-state run on the settings thread that sat in a
+* syscall sat in `fsync` (74), each within ±2 s of a checkpoint event —
+* 12.6 s of the 569 s window, all of it inside writers' commits. In the two
+* saturated bursts earlier that morning (08:35–08:40, 09:30–09:39) the same
+* fsync took 1–10 s, once per checkpoint, and the profiler filed each as a
+* slow `set`. `synchronous` was never the lever: it was already NORMAL, and
+* `sqlite-pragmas.ts` had said so since 2026-08-08.
+*
+* So the checkpoint runs on a worker thread, over its own connection. The
+* settings thread's commits stay appends. What stays on the settings thread
+* is the WAL-header sync SQLite performs when a WAL is reused after a
+* completed checkpoint — one small fsync per cycle — and that residual is
+* named here so nobody reads "no fsync on the settings thread" into this.
+*
+* ## The rule this file reproduces
+*
+* The auto-checkpoint's own rule: fold when 1000 frames are pending. The
+* point of moving the checkpoint is to change WHO waits on the disk, not how
+* often the disk is asked to sync — a worker that folded every second would
+* multiply the fsync count on a drive the media plane already saturates.
+*
+* ## How the worker knows how much is pending — and how it must NOT learn it
+*
+* Until 2026-09-29 the worker read the wal-index header straight out of the
+* `-shm` file, once a second, with `openSync` / `readSync` / `closeSync`. That
+* `closeSync` was the SIGBUS of D468 (corrected by D679): on POSIX, closing
+* ANY descriptor of a file drops EVERY fcntl lock the process holds on that
+* file — including the shared lock on `-shm` byte 128 (the "DMS" lock) that
+* SQLite takes for the life of a connection and that tells every OTHER
+* process "a live connection is using this wal-index, do not rebuild it". With
+* the lock gone, the next process to open the database believed it was
+* first, truncated and re-initialised the `-shm` under the runner's mappings,
+* and the runner's next write past a 32 KiB wal-index region hit a page
+* beyond end-of-file.
+*
+* So the worker never touches a SQLite file except through its connection.
+* What it knows about the WAL it learns from the checkpoint it just ran:
+* `PRAGMA wal_checkpoint(PASSIVE)` answers `log` (frames in the WAL) and
+* `checkpointed` (frames now backfilled). Two consecutive answers give the
+* frames appended between them, hence a rate, hence WHEN the next 1000 frames
+* will have accumulated. The next checkpoint is scheduled for then —
+* {@link nextCheckpointPlan} — clamped between the worker's poll interval and
+* {@link WAL_CHECKPOINT_MAX_DELAY_MS}. A PASSIVE with nothing to fold performs
+* no fsync (the copy and both syncs sit behind `nBackfill < mxFrame` in
+* `wal.c`), so the clamp costs a quiet database nothing, and it bounds how
+* long a burst that follows a quiet spell goes unseen.
+*/
+/** The engine's own `wal_autocheckpoint` default, in frames. Reproduced, not changed. */
+var WAL_CHECKPOINT_THRESHOLD_FRAMES = 1e3;
+/**
+* Longest the worker waits between two checkpoints, in ms, whatever the
+* measured rate says. It is the bound on how late a burst after a steady or
+* quiet spell is noticed, and it is sized against the engine's own fallback
+* (`SQLITE_WAL_AUTOCHECKPOINT_BOUND_PAGES` = 10 000 frames), which runs INSIDE
+* a settings-thread commit — the stall D452 moved off that thread. No burst
+* rate has been measured on the hub (D452's 54 frames/s is the steady rate),
+* so the design point is 1 000 frames/s, ~18× steady: 8 s of it is 8 000
+* frames, under the fallback, so the worker looks before the engine has to.
+* A pass that finds more than {@link WAL_CHECKPOINT_LARGE_PASS_FRAMES} is
+* reported so this number can be tuned from the field.
+*
+* The cost, stated against D452: at the steady 54 frames/s the threshold
+* would fold every ~18.5 s; this clamp folds every 8 s, ~2.3× the fsync pairs
+* (≈ 432 frames per fold instead of 1 000). They are paid on the WORKER, a
+* thread nobody waits on — the settings thread's commits stay appends. A pass
+* with nothing pending does no fsync at all.
+*/
+var WAL_CHECKPOINT_MAX_DELAY_MS = 8e3;
+/**
+* A pass that folded more than this many appended frames is reported (WARN,
+* sampled: the first of each summary window, the rest counted). Half the
+* engine's fallback bound: a gap that let this much accumulate was within 2×
+* of handing the checkpoint back to the settings thread.
+*/
+var WAL_CHECKPOINT_LARGE_PASS_FRAMES = 5e3;
+/** Shortest gap between two checkpoints, in ms — the worker's poll interval. */
+var WAL_CHECKPOINT_POLL_MS = 1e3;
+/**
+* A checkpoint that took this long is reported at WARN with its numbers.
+* Matched to `SQLITE_SLOW_CALL_MS`: it is the same "the disk held us" event
+* the profiler used to file as a slow `set`, now on the thread that paid it.
+*/
+var WAL_CHECKPOINT_SLOW_MS = 1e3;
+/**
+* Frames appended to the WAL between two checkpoints.
+*
+* When the previous checkpoint backfilled EVERYTHING, the next writer restarts
+* the WAL from frame 1, so every frame now in it is new. When it did not (a
+* reader pinned a snapshot), the WAL kept growing and the difference is what
+* was added — unless it shrank, which only a restart can do.
+*
+* An IDLE WAL is the exception to "complete means restarted": the WAL restarts
+* only at the next write, so a fully checkpointed WAL nobody writes answers
+* the same `log == checkpointed` pass after pass. Identical answers after a
+* complete checkpoint are therefore 0 appended, not the whole WAL again —
+* otherwise an idle node would be scheduled at the poll interval forever and
+* every summary would count the same frames once per pass. (A restart that
+* appended exactly as many frames as the previous cycle is read as idle too;
+* it is scheduled at the max delay, which is the bounded case anyway.)
+*
+* The one remaining ambiguity — a complete checkpoint followed by writes the
+* writer could NOT restart the WAL for — counts old frames as new, which
+* over-estimates the rate and checkpoints EARLY: the safe direction. `-1`
+* (not a WAL database, or a busy pass) reads as 0.
+*/
+function framesAppendedBetween(previous, current) {
+	const prevWal = Math.max(0, previous.walFrames);
+	const prevDone = Math.max(0, previous.checkpointedFrames);
+	const curWal = Math.max(0, current.walFrames);
+	const curDone = Math.max(0, current.checkpointedFrames);
+	if (prevDone >= prevWal) {
+		if (curWal === prevWal && curDone === prevDone) return 0;
+		return curWal;
+	}
+	return curWal >= prevWal ? curWal - prevWal : curWal;
+}
+/**
+* What the worker "saw" before its first checkpoint: nothing, at the moment it
+* started. Against it, the first checkpoint counts every frame then in the WAL
+* as appended since the start — which over-estimates the rate when the WAL
+* held older frames, and so schedules the second checkpoint EARLY: the safe
+* direction, and the second one measures the real rate.
+*/
+function workerStartObservation(at) {
+	return {
+		at,
+		walFrames: 0,
+		checkpointedFrames: 0
+	};
+}
+/**
+* When to run the next checkpoint: the moment the measured rate says
+* {@link WAL_CHECKPOINT_THRESHOLD_FRAMES} more frames will be pending,
+* clamped to `[minDelayMs, maxDelayMs]`. Nothing appended since the last one
+* is `maxDelayMs`.
+*/
+function nextCheckpointPlan(input) {
+	const { previous, current, minDelayMs, maxDelayMs } = input;
+	const appendedFrames = framesAppendedBetween(previous, current);
+	const elapsedMs = Math.max(1, current.at - previous.at);
+	if (appendedFrames === 0) return {
+		appendedFrames,
+		nextDelayMs: maxDelayMs
+	};
+	const untilThresholdMs = WAL_CHECKPOINT_THRESHOLD_FRAMES / (appendedFrames / elapsedMs);
+	return {
+		appendedFrames,
+		nextDelayMs: Math.round(Math.min(maxDelayMs, Math.max(minDelayMs, untilThresholdMs)))
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Narrow a message off the worker port without a cast. */
+function isWorkerMessage(value) {
+	if (!isRecord(value)) return false;
+	switch (value["kind"]) {
+		case "ready": return true;
+		case "failed": return typeof value["error"] === "string";
+		case "checkpointed": return (value["reason"] === "first" || value["reason"] === "scheduled") && typeof value["appendedFrames"] === "number" && typeof value["nextDelayMs"] === "number" && typeof value["walFrames"] === "number" && typeof value["checkpointedFrames"] === "number" && typeof value["busy"] === "boolean" && typeof value["ms"] === "number";
+		default: return false;
+	}
+}
+function isWorkerStop(value) {
+	return isRecord(value) && value["kind"] === "stop";
+}
+//#endregion
+Object.defineProperty(exports, "WAL_CHECKPOINT_LARGE_PASS_FRAMES", {
+	enumerable: true,
+	get: function() {
+		return WAL_CHECKPOINT_LARGE_PASS_FRAMES;
+	}
+});
+Object.defineProperty(exports, "WAL_CHECKPOINT_MAX_DELAY_MS", {
+	enumerable: true,
+	get: function() {
+		return WAL_CHECKPOINT_MAX_DELAY_MS;
+	}
+});
+Object.defineProperty(exports, "WAL_CHECKPOINT_POLL_MS", {
+	enumerable: true,
+	get: function() {
+		return WAL_CHECKPOINT_POLL_MS;
+	}
+});
+Object.defineProperty(exports, "WAL_CHECKPOINT_SLOW_MS", {
+	enumerable: true,
+	get: function() {
+		return WAL_CHECKPOINT_SLOW_MS;
+	}
+});
+Object.defineProperty(exports, "isWorkerMessage", {
+	enumerable: true,
+	get: function() {
+		return isWorkerMessage;
+	}
+});
+Object.defineProperty(exports, "isWorkerStop", {
+	enumerable: true,
+	get: function() {
+		return isWorkerStop;
+	}
+});
+Object.defineProperty(exports, "nextCheckpointPlan", {
+	enumerable: true,
+	get: function() {
+		return nextCheckpointPlan;
+	}
+});
+Object.defineProperty(exports, "workerStartObservation", {
+	enumerable: true,
+	get: function() {
+		return workerStartObservation;
+	}
+});

package/dist/wal-checkpoint-worker.js

@@ -1,6 +1,5 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_wal_checkpoint_policy = require("./wal-checkpoint-policy-CCJZngds.js");
-let node_fs = require("node:fs");
+const require_wal_checkpoint_policy = require("./wal-checkpoint-policy-d2z2qPqx.js");
 let better_sqlite3 = require("better-sqlite3");
 better_sqlite3 = require_chunk.__toESM(better_sqlite3);
 let node_worker_threads = require("node:worker_threads");
@@ -22,9 +21,15 @@ let node_worker_threads = require("node:worker_threads");
 *   writers and readers are never blocked by this thread. (The idle-gated
 *   TRUNCATE in `wal-maintenance.ts` is a different job — reclaiming a
 *   sidecar that outgrew its limit — and stays where it is.)
-* - The wal-index header is read as bytes (`-shm`, 100 bytes, no lock) so the
-*   poll costs nothing; when it cannot be read the policy falls back to a
-*   fixed interval, so nothing here can turn "unreadable" into "nothing to do".
+* - It NEVER touches a SQLite file except through that connection — no
+*   `open`/`read`/`close` of the `.db`, `-wal` or `-shm`. Until 2026-09-29 it
+*   read the wal-index header out of `-shm` once a second, and each
+*   `closeSync` dropped every fcntl lock this PROCESS held on the file —
+*   SQLite's DMS lock included — which let the nightly backup's connection
+*   rebuild the `-shm` under the runner's mappings: the SIGBUS of D468,
+*   diagnosed in D679. `scripts/check-sqlite-files-not-opened-by-fs.ts`
+*   refuses the pattern. The schedule is derived from the checkpoints'
+*   own answers instead (`nextCheckpointPlan`).
 * - Every checkpoint is reported to the parent with its numbers. The parent
 *   decides what is worth a line.
 *
@@ -48,31 +53,8 @@ function readCheckpointRow(value) {
 }
 function isWorkerData(value) {
 	if (typeof value !== "object" || value === null) return false;
-	if (!("dbPath" in value) || !("pollMs" in value)) return false;
-	return typeof value.dbPath === "string" && typeof value.pollMs === "number";
-}
-/** The two wal-index counters, or nulls when the sidecar cannot be read. */
-function readWalIndex(shmPath) {
-	let fd = null;
-	try {
-		fd = (0, node_fs.openSync)(shmPath, "r");
-		const buffer = Buffer.alloc(100);
-		if ((0, node_fs.readSync)(fd, buffer, 0, 100, 0) < 100) return {
-			mxFrame: null,
-			nBackfill: null
-		};
-		return require_wal_checkpoint_policy.parseWalIndexHeader(buffer) ?? {
-			mxFrame: null,
-			nBackfill: null
-		};
-	} catch {
-		return {
-			mxFrame: null,
-			nBackfill: null
-		};
-	} finally {
-		if (fd !== null) (0, node_fs.closeSync)(fd);
-	}
+	if (!("dbPath" in value) || !("pollMs" in value) || !("maxDelayMs" in value)) return false;
+	return typeof value.dbPath === "string" && typeof value.pollMs === "number" && typeof value.maxDelayMs === "number";
 }
 function post(message) {
 	node_worker_threads.parentPort?.postMessage(message);
@@ -81,45 +63,69 @@ function run() {
 	const port = node_worker_threads.parentPort;
 	if (port === null) throw new Error("wal-checkpoint-worker: no parent port");
 	if (!isWorkerData(node_worker_threads.workerData)) throw new Error("wal-checkpoint-worker: bad workerData");
-	const { dbPath, pollMs } = node_worker_threads.workerData;
-	const shmPath = `${dbPath}-shm`;
+	const { dbPath, pollMs, maxDelayMs } = node_worker_threads.workerData;
 	const db = new better_sqlite3.default(dbPath);
 	db.pragma("cache_size = -2048");
 	db.pragma("mmap_size = 0");
-	let lastRunAt = Date.now();
+	let previous = require_wal_checkpoint_policy.workerStartObservation(Date.now());
+	let first = true;
 	let timer = null;
 	let stopping = false;
 	const tick = () => {
 		if (stopping) return;
-		const decision = require_wal_checkpoint_policy.decideCheckpoint({
-			...readWalIndex(shmPath),
-			sinceLastRunMs: Date.now() - lastRunAt
-		});
-		if (decision.run) {
-			const startedAt = Date.now();
-			let raw;
-			try {
-				raw = db.pragma("wal_checkpoint(PASSIVE)");
-			} catch (err) {
-				post({
-					kind: "failed",
-					error: err instanceof Error ? err.message : String(err)
-				});
-				raw = null;
-			}
-			lastRunAt = Date.now();
-			const row = readCheckpointRow(raw);
-			if (row !== null) post({
+		const startedAt = Date.now();
+		let raw = null;
+		try {
+			raw = db.pragma("wal_checkpoint(PASSIVE)");
+		} catch (err) {
+			post({
+				kind: "failed",
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+		const row = readCheckpointRow(raw);
+		if (row === null) {
+			timer = setTimeout(tick, maxDelayMs);
+			return;
+		}
+		if (row.busy !== 0) {
+			post({
 				kind: "checkpointed",
-				reason: decision.reason,
-				pendingFrames: decision.pendingFrames,
+				reason: first ? "first" : "scheduled",
+				appendedFrames: 0,
+				nextDelayMs: pollMs,
 				walFrames: row.log,
 				checkpointedFrames: row.checkpointed,
-				busy: row.busy !== 0,
-				ms: lastRunAt - startedAt
+				busy: true,
+				ms: Date.now() - startedAt
 			});
+			timer = setTimeout(tick, pollMs);
+			return;
 		}
-		timer = setTimeout(tick, pollMs);
+		const current = {
+			at: Date.now(),
+			walFrames: row.log,
+			checkpointedFrames: row.checkpointed
+		};
+		const plan = require_wal_checkpoint_policy.nextCheckpointPlan({
+			previous,
+			current,
+			minDelayMs: pollMs,
+			maxDelayMs
+		});
+		post({
+			kind: "checkpointed",
+			reason: first ? "first" : "scheduled",
+			appendedFrames: plan.appendedFrames,
+			nextDelayMs: plan.nextDelayMs,
+			walFrames: row.log,
+			checkpointedFrames: row.checkpointed,
+			busy: row.busy !== 0,
+			ms: current.at - startedAt
+		});
+		previous = current;
+		first = false;
+		timer = setTimeout(tick, plan.nextDelayMs);
 	};
 	port.on("message", (message) => {
 		if (!require_wal_checkpoint_policy.isWorkerStop(message)) return;

package/dist/wal-checkpoint-worker.mjs

@@ -1,5 +1,4 @@
-import { a as isWorkerStop, o as parseWalIndexHeader, r as decideCheckpoint } from "./wal-checkpoint-policy-CAcg63o-.mjs";
-import { closeSync, openSync, readSync } from "node:fs";
+import { c as workerStartObservation, o as isWorkerStop, s as nextCheckpointPlan } from "./wal-checkpoint-policy-BahrTtyD.mjs";
 import Database from "better-sqlite3";
 import { parentPort, workerData } from "node:worker_threads";
 //#region src/builtins/sqlite-storage/wal-checkpoint-worker.ts
@@ -20,9 +19,15 @@ import { parentPort, workerData } from "node:worker_threads";
 *   writers and readers are never blocked by this thread. (The idle-gated
 *   TRUNCATE in `wal-maintenance.ts` is a different job — reclaiming a
 *   sidecar that outgrew its limit — and stays where it is.)
-* - The wal-index header is read as bytes (`-shm`, 100 bytes, no lock) so the
-*   poll costs nothing; when it cannot be read the policy falls back to a
-*   fixed interval, so nothing here can turn "unreadable" into "nothing to do".
+* - It NEVER touches a SQLite file except through that connection — no
+*   `open`/`read`/`close` of the `.db`, `-wal` or `-shm`. Until 2026-09-29 it
+*   read the wal-index header out of `-shm` once a second, and each
+*   `closeSync` dropped every fcntl lock this PROCESS held on the file —
+*   SQLite's DMS lock included — which let the nightly backup's connection
+*   rebuild the `-shm` under the runner's mappings: the SIGBUS of D468,
+*   diagnosed in D679. `scripts/check-sqlite-files-not-opened-by-fs.ts`
+*   refuses the pattern. The schedule is derived from the checkpoints'
+*   own answers instead (`nextCheckpointPlan`).
 * - Every checkpoint is reported to the parent with its numbers. The parent
 *   decides what is worth a line.
 *
@@ -46,31 +51,8 @@ function readCheckpointRow(value) {
 }
 function isWorkerData(value) {
 	if (typeof value !== "object" || value === null) return false;
-	if (!("dbPath" in value) || !("pollMs" in value)) return false;
-	return typeof value.dbPath === "string" && typeof value.pollMs === "number";
-}
-/** The two wal-index counters, or nulls when the sidecar cannot be read. */
-function readWalIndex(shmPath) {
-	let fd = null;
-	try {
-		fd = openSync(shmPath, "r");
-		const buffer = Buffer.alloc(100);
-		if (readSync(fd, buffer, 0, 100, 0) < 100) return {
-			mxFrame: null,
-			nBackfill: null
-		};
-		return parseWalIndexHeader(buffer) ?? {
-			mxFrame: null,
-			nBackfill: null
-		};
-	} catch {
-		return {
-			mxFrame: null,
-			nBackfill: null
-		};
-	} finally {
-		if (fd !== null) closeSync(fd);
-	}
+	if (!("dbPath" in value) || !("pollMs" in value) || !("maxDelayMs" in value)) return false;
+	return typeof value.dbPath === "string" && typeof value.pollMs === "number" && typeof value.maxDelayMs === "number";
 }
 function post(message) {
 	parentPort?.postMessage(message);
@@ -79,45 +61,69 @@ function run() {
 	const port = parentPort;
 	if (port === null) throw new Error("wal-checkpoint-worker: no parent port");
 	if (!isWorkerData(workerData)) throw new Error("wal-checkpoint-worker: bad workerData");
-	const { dbPath, pollMs } = workerData;
-	const shmPath = `${dbPath}-shm`;
+	const { dbPath, pollMs, maxDelayMs } = workerData;
 	const db = new Database(dbPath);
 	db.pragma("cache_size = -2048");
 	db.pragma("mmap_size = 0");
-	let lastRunAt = Date.now();
+	let previous = workerStartObservation(Date.now());
+	let first = true;
 	let timer = null;
 	let stopping = false;
 	const tick = () => {
 		if (stopping) return;
-		const decision = decideCheckpoint({
-			...readWalIndex(shmPath),
-			sinceLastRunMs: Date.now() - lastRunAt
-		});
-		if (decision.run) {
-			const startedAt = Date.now();
-			let raw;
-			try {
-				raw = db.pragma("wal_checkpoint(PASSIVE)");
-			} catch (err) {
-				post({
-					kind: "failed",
-					error: err instanceof Error ? err.message : String(err)
-				});
-				raw = null;
-			}
-			lastRunAt = Date.now();
-			const row = readCheckpointRow(raw);
-			if (row !== null) post({
+		const startedAt = Date.now();
+		let raw = null;
+		try {
+			raw = db.pragma("wal_checkpoint(PASSIVE)");
+		} catch (err) {
+			post({
+				kind: "failed",
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+		const row = readCheckpointRow(raw);
+		if (row === null) {
+			timer = setTimeout(tick, maxDelayMs);
+			return;
+		}
+		if (row.busy !== 0) {
+			post({
 				kind: "checkpointed",
-				reason: decision.reason,
-				pendingFrames: decision.pendingFrames,
+				reason: first ? "first" : "scheduled",
+				appendedFrames: 0,
+				nextDelayMs: pollMs,
 				walFrames: row.log,
 				checkpointedFrames: row.checkpointed,
-				busy: row.busy !== 0,
-				ms: lastRunAt - startedAt
+				busy: true,
+				ms: Date.now() - startedAt
 			});
+			timer = setTimeout(tick, pollMs);
+			return;
 		}
-		timer = setTimeout(tick, pollMs);
+		const current = {
+			at: Date.now(),
+			walFrames: row.log,
+			checkpointedFrames: row.checkpointed
+		};
+		const plan = nextCheckpointPlan({
+			previous,
+			current,
+			minDelayMs: pollMs,
+			maxDelayMs
+		});
+		post({
+			kind: "checkpointed",
+			reason: first ? "first" : "scheduled",
+			appendedFrames: plan.appendedFrames,
+			nextDelayMs: plan.nextDelayMs,
+			walFrames: row.log,
+			checkpointedFrames: row.checkpointed,
+			busy: row.busy !== 0,
+			ms: current.at - startedAt
+		});
+		previous = current;
+		first = false;
+		timer = setTimeout(tick, plan.nextDelayMs);
 	};
 	port.on("message", (message) => {
 		if (!isWorkerStop(message)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.317",
+  "version": "1.2.319",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",

package/dist/wal-checkpoint-policy-CAcg63o-.mjs

@@ -1,92 +0,0 @@
-/**
-* Longest the worker lets pending frames sit before folding them, in ms. A
-* quiet database (a developer machine, an agent with little to persist) still
-* gets its WAL folded and its pages made durable within a minute.
-*/
-var WAL_CHECKPOINT_MAX_INTERVAL_MS = 6e4;
-/** How often the worker looks at the wal-index, in ms. A 136-byte read. */
-var WAL_CHECKPOINT_POLL_MS = 1e3;
-/**
-* A checkpoint that took this long is reported at WARN with its numbers.
-* Matched to `SQLITE_SLOW_CALL_MS`: it is the same "the disk held us" event
-* the profiler used to file as a slow `set`, now on the thread that paid it.
-*/
-var WAL_CHECKPOINT_SLOW_MS = 1e3;
-/** Should the worker run `wal_checkpoint(PASSIVE)` now? */
-function decideCheckpoint(input) {
-	const intervalDue = input.sinceLastRunMs >= WAL_CHECKPOINT_MAX_INTERVAL_MS;
-	if (input.mxFrame === null || input.nBackfill === null) return intervalDue ? {
-		run: true,
-		reason: "unknown-interval",
-		pendingFrames: null
-	} : {
-		run: false,
-		reason: "unknown-below-interval",
-		pendingFrames: null
-	};
-	const pendingFrames = Math.max(0, input.mxFrame - input.nBackfill);
-	if (pendingFrames === 0) return {
-		run: false,
-		reason: "nothing-pending",
-		pendingFrames
-	};
-	if (pendingFrames >= 1e3) return {
-		run: true,
-		reason: "threshold",
-		pendingFrames
-	};
-	if (intervalDue) return {
-		run: true,
-		reason: "interval",
-		pendingFrames
-	};
-	return {
-		run: false,
-		reason: "below-threshold",
-		pendingFrames
-	};
-}
-/**
-* Byte offsets in the `-shm` file, from `wal.c` ("WAL-index file format"):
-* two copies of the 48-byte `WalIndexHdr` (copy 2 at 48), then `WalCkptInfo`
-* at 96 whose first field is `nBackfill`. `mxFrame` is at byte 16 of the
-* header. Both are u32 in the writer's native byte order — little-endian on
-* every x86-64 and arm64 node this ships to.
-*/
-var WAL_INDEX_MXFRAME_OFFSET = 16;
-var WAL_INDEX_HDR_SIZE = 48;
-var WAL_INDEX_NBACKFILL_OFFSET = 96;
-/**
-* `mxFrame` and `nBackfill` from the first {@link WAL_INDEX_HEADER_READ_BYTES}
-* of the `-shm` file, or `null` when the buffer is short or the two header
-* copies disagree (a writer was updating them — SQLite's own readers retry on
-* exactly that comparison; this caller simply waits for the next poll).
-*/
-function parseWalIndexHeader(buffer) {
-	if (buffer.length < 100) return null;
-	const copy1 = buffer.subarray(0, WAL_INDEX_HDR_SIZE);
-	const copy2 = buffer.subarray(WAL_INDEX_HDR_SIZE, WAL_INDEX_HDR_SIZE * 2);
-	if (!copy1.equals(copy2)) return null;
-	return {
-		mxFrame: buffer.readUInt32LE(WAL_INDEX_MXFRAME_OFFSET),
-		nBackfill: buffer.readUInt32LE(WAL_INDEX_NBACKFILL_OFFSET)
-	};
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-/** Narrow a message off the worker port without a cast. */
-function isWorkerMessage(value) {
-	if (!isRecord(value)) return false;
-	switch (value["kind"]) {
-		case "ready": return true;
-		case "failed": return typeof value["error"] === "string";
-		case "checkpointed": return typeof value["reason"] === "string" && (typeof value["pendingFrames"] === "number" || value["pendingFrames"] === null) && typeof value["walFrames"] === "number" && typeof value["checkpointedFrames"] === "number" && typeof value["busy"] === "boolean" && typeof value["ms"] === "number";
-		default: return false;
-	}
-}
-function isWorkerStop(value) {
-	return isRecord(value) && value["kind"] === "stop";
-}
-//#endregion
-export { isWorkerStop as a, isWorkerMessage as i, WAL_CHECKPOINT_SLOW_MS as n, parseWalIndexHeader as o, decideCheckpoint as r, WAL_CHECKPOINT_POLL_MS as t };