@camstack/system 1.2.318 → 1.2.320

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.318",
+  "version": "1.2.320",
   "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 };

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

@@ -1,127 +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
-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, "decideCheckpoint", {
-	enumerable: true,
-	get: function() {
-		return decideCheckpoint;
-	}
-});
-Object.defineProperty(exports, "isWorkerMessage", {
-	enumerable: true,
-	get: function() {
-		return isWorkerMessage;
-	}
-});
-Object.defineProperty(exports, "isWorkerStop", {
-	enumerable: true,
-	get: function() {
-		return isWorkerStop;
-	}
-});
-Object.defineProperty(exports, "parseWalIndexHeader", {
-	enumerable: true,
-	get: function() {
-		return parseWalIndexHeader;
-	}
-});