@camstack/system 1.2.218 → 1.2.219

package/dist/process/proc-stat.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Kernel jiffies per second (`USER_HZ`). `sysconf(_SC_CLK_TCK)` is not exposed
+ * to Node, and this has been 100 on every Linux/x86-64 and arm64 kernel
+ * configuration we ship to. A wrong value would scale every CPU number and
+ * every elapsed time by one constant — visible at once, not a silent skew.
+ */
+export declare const CLOCK_TICKS_PER_SEC = 100;
+/** The fields of one `/proc/<pid>/stat` line this repository reads. */
+export interface ProcStat {
+    readonly pid: number;
+    readonly comm: string;
+    /** Field 3: `R`, `S`, `D`, `Z`, … */
+    readonly state: string;
+    readonly ppid: number;
+    readonly pgid: number;
+    /** `utime + stime`, in jiffies, over the process's whole life. */
+    readonly ticks: number;
+    /** Field 22: jiffies since boot at which this incarnation of the pid began. */
+    readonly startTicks: number;
+    /** Field 24: resident pages. Prefer `VmRSS` from `status`, which is in kB. */
+    readonly rssPages: number;
+}
+/**
+ * Parse one `/proc/<pid>/stat` line. `null` for a line that does not parse —
+ * a process that exited between the readdir and the read leaves a truncated
+ * or empty file, and that is normal, not an error.
+ */
+export declare function parseProcStat(line: string): ProcStat | null;
+/** Resident memory from `/proc/<pid>/status`, in bytes. Absent is `undefined`, never 0. */
+export interface ProcStatusRss {
+    /** `VmRSS` — what `ps rss` prints. */
+    readonly rssBytes: number | undefined;
+    /** `RssAnon` — private anonymous memory, the runner's own cost. */
+    readonly privateBytes: number | undefined;
+    /** `RssFile` — file-backed pages shared with every process mapping the same files. */
+    readonly sharedBytes: number | undefined;
+}
+/** Read `VmRSS` / `RssAnon` / `RssFile` (kB in the file) out of `/proc/<pid>/status`. */
+export declare function parseProcStatusRss(status: string): ProcStatusRss;
+/** Inputs for the two `ps`-compatible derivations below. */
+export interface LifetimeCpuInput {
+    readonly ticks: number;
+    readonly startTicks: number;
+    /** First field of `/proc/uptime`, seconds since boot. */
+    readonly uptimeSec: number;
+}
+/** Seconds the process has been alive — `ps etime`, whole seconds. */
+export declare function elapsedSecSince(input: Pick<LifetimeCpuInput, 'startTicks' | 'uptimeSec'>): number;
+/**
+ * `ps pcpu`: CPU time over elapsed time, as a percentage with one decimal.
+ *
+ * This is deliberately the LIFETIME average `ps` prints, not an instantaneous
+ * rate: the columns fed from it have always shown that quantity, and the
+ * instantaneous split is a different number with a different owner
+ * (`cpuMainPercent` / `cpuGcPercent` from `thread-cpu-sampler.ts`). A process
+ * with no elapsed window yet reports 0, never a division by zero.
+ */
+export declare function lifetimeCpuPercent(input: LifetimeCpuInput): number;
+/**
+ * The procfs surface, injectable — the whole reason the readers above are
+ * testable against fixtures rather than against a Linux kernel.
+ */
+export interface ProcReader {
+    /** Numeric entries of `/proc`. */
+    readonly listPids: () => Promise<readonly number[]>;
+    readonly readStat: (pid: number) => Promise<string>;
+    readonly readStatus: (pid: number) => Promise<string>;
+    /** Raw `/proc/<pid>/cmdline`: NUL-separated argv, empty for a kernel thread. */
+    readonly readCmdline: (pid: number) => Promise<string>;
+    /** First field of `/proc/uptime`. */
+    readonly readUptimeSec: () => Promise<number>;
+}
+export declare const nodeProcReader: ProcReader;
+/** `ps command=`: argv joined by spaces, or `[comm]` when there is no argv. */
+export declare function commandFromCmdline(cmdline: string, comm: string): string;

package/dist/process/resource-monitor.d.ts

@@ -1,3 +1,4 @@
+import { ProcReader } from './proc-stat.js';
 export interface PidStats {
     cpu: number;
     memory: number;
@@ -11,10 +12,17 @@ export interface PidStats {
     /** Shared file-backed resident bytes (Linux RssFile). undefined on macOS. */
     sharedBytes?: number;
 }
+/** The impure inputs, injectable so the platform branch is pinned by a test. */
+export interface PidStatsDeps {
+    readonly platform: NodeJS.Platform;
+    readonly reader: ProcReader;
+    /** `ps -o pid=,pcpu=,rss= -p <pids>` — the fork, for a platform without `/proc`. */
+    readonly spawnPs: (pids: readonly number[]) => Promise<string>;
+}
 /**
  * Get CPU% and memory RSS for one or more PIDs.
  * Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
  */
-export declare function getPidStats(pids: number | readonly number[]): Promise<ReadonlyMap<number, PidStats>>;
+export declare function getPidStats(pids: number | readonly number[], deps?: PidStatsDeps): Promise<ReadonlyMap<number, PidStats>>;
 /** Get CPU% and memory RSS for a single PID. Returns null if dead. */
 export declare function getSinglePidStats(pid: number): Promise<PidStats | null>;

package/dist/{resource-monitor-CdnzxBLP.js → resource-monitor-LVE1BoLs.js}

@@ -1,29 +1,12 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
+const require_builtins_native_metrics_native_metrics_addon = require("./builtins/native-metrics/native-metrics.addon.js");
 let node_child_process = require("node:child_process");
-let node_fs = require("node:fs");
-node_fs = require_chunk.__toESM(node_fs);
+let node_os = require("node:os");
 //#region src/process/resource-monitor.ts
 var resource_monitor_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	getPidStats: () => getPidStats,
 	getSinglePidStats: () => getSinglePidStats
 });
-/**
-* Read RssAnon / RssFile (KB) from /proc/<pid>/status. Linux-only; returns
-* undefined fields anywhere /proc is absent. Cheap (one small file read).
-*/
-function readProcRss(pid) {
-	try {
-		const status = node_fs.readFileSync(`/proc/${pid}/status`, "utf8");
-		const anon = status.match(/^RssAnon:\s+(\d+)/m);
-		const file = status.match(/^RssFile:\s+(\d+)/m);
-		return {
-			privateBytes: anon ? parseInt(anon[1], 10) * 1024 : void 0,
-			sharedBytes: file ? parseInt(file[1], 10) * 1024 : void 0
-		};
-	} catch {
-		return {};
-	}
-}
 function execPsForPids(pids) {
 	return new Promise((resolve, reject) => {
 		(0, node_child_process.execFile)("ps", [
@@ -37,6 +20,11 @@ function execPsForPids(pids) {
 		});
 	});
 }
+var defaultDeps = {
+	platform: (0, node_os.platform)(),
+	reader: require_builtins_native_metrics_native_metrics_addon.nodeProcReader,
+	spawnPs: execPsForPids
+};
 function parsePsOutput(stdout) {
 	const result = /* @__PURE__ */ new Map();
 	for (const line of stdout.trim().split("\n")) {
@@ -50,21 +38,52 @@ function parsePsOutput(stdout) {
 		if (isNaN(pid) || isNaN(cpu) || isNaN(rssKb)) continue;
 		result.set(pid, {
 			cpu: Math.round(cpu * 10) / 10,
-			memory: rssKb * 1024,
-			...readProcRss(pid)
+			memory: rssKb * 1024
 		});
 	}
 	return result;
 }
+/** One pid from `/proc`, or `null` when it is gone or unreadable. */
+async function readProcPidStats(pid, uptimeSec, reader) {
+	let stat;
+	let status;
+	try {
+		[stat, status] = await Promise.all([reader.readStat(pid), reader.readStatus(pid)]);
+	} catch {
+		return null;
+	}
+	const parsed = require_builtins_native_metrics_native_metrics_addon.parseProcStat(stat);
+	if (parsed === null) return null;
+	const rss = require_builtins_native_metrics_native_metrics_addon.parseProcStatusRss(status);
+	if (rss.rssBytes === void 0) return null;
+	return {
+		cpu: require_builtins_native_metrics_native_metrics_addon.lifetimeCpuPercent({
+			ticks: parsed.ticks,
+			startTicks: parsed.startTicks,
+			uptimeSec
+		}),
+		memory: rss.rssBytes,
+		privateBytes: rss.privateBytes,
+		sharedBytes: rss.sharedBytes
+	};
+}
+async function readProcPidStatsAll(pids, reader) {
+	const uptimeSec = await reader.readUptimeSec();
+	const entries = await Promise.all(pids.map(async (pid) => [pid, await readProcPidStats(pid, uptimeSec, reader)]));
+	const result = /* @__PURE__ */ new Map();
+	for (const [pid, stats] of entries) if (stats !== null) result.set(pid, stats);
+	return result;
+}
 /**
 * Get CPU% and memory RSS for one or more PIDs.
 * Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
 */
-async function getPidStats(pids) {
+async function getPidStats(pids, deps = defaultDeps) {
 	const pidArray = typeof pids === "number" ? [pids] : [...pids];
 	if (pidArray.length === 0) return /* @__PURE__ */ new Map();
 	try {
-		return parsePsOutput(await execPsForPids(pidArray));
+		if (deps.platform === "linux") return await readProcPidStatsAll(pidArray, deps.reader);
+		return parsePsOutput(await deps.spawnPs(pidArray));
 	} catch {
 		return /* @__PURE__ */ new Map();
 	}

package/dist/{resource-monitor-BWmQ5i-o.mjs → resource-monitor-Vp0bPV3U.mjs}

@@ -1,28 +1,12 @@
 import { r as __exportAll } from "./chunk-CNf5ZN-e.mjs";
+import { i as parseProcStatusRss, n as nodeProcReader, r as parseProcStat, t as lifetimeCpuPercent } from "./builtins/native-metrics/native-metrics.addon.mjs";
 import { execFile } from "node:child_process";
-import * as fs from "node:fs";
+import { platform } from "node:os";
 //#region src/process/resource-monitor.ts
 var resource_monitor_exports = /* @__PURE__ */ __exportAll({
 	getPidStats: () => getPidStats,
 	getSinglePidStats: () => getSinglePidStats
 });
-/**
-* Read RssAnon / RssFile (KB) from /proc/<pid>/status. Linux-only; returns
-* undefined fields anywhere /proc is absent. Cheap (one small file read).
-*/
-function readProcRss(pid) {
-	try {
-		const status = fs.readFileSync(`/proc/${pid}/status`, "utf8");
-		const anon = status.match(/^RssAnon:\s+(\d+)/m);
-		const file = status.match(/^RssFile:\s+(\d+)/m);
-		return {
-			privateBytes: anon ? parseInt(anon[1], 10) * 1024 : void 0,
-			sharedBytes: file ? parseInt(file[1], 10) * 1024 : void 0
-		};
-	} catch {
-		return {};
-	}
-}
 function execPsForPids(pids) {
 	return new Promise((resolve, reject) => {
 		execFile("ps", [
@@ -36,6 +20,11 @@ function execPsForPids(pids) {
 		});
 	});
 }
+var defaultDeps = {
+	platform: platform(),
+	reader: nodeProcReader,
+	spawnPs: execPsForPids
+};
 function parsePsOutput(stdout) {
 	const result = /* @__PURE__ */ new Map();
 	for (const line of stdout.trim().split("\n")) {
@@ -49,21 +38,52 @@ function parsePsOutput(stdout) {
 		if (isNaN(pid) || isNaN(cpu) || isNaN(rssKb)) continue;
 		result.set(pid, {
 			cpu: Math.round(cpu * 10) / 10,
-			memory: rssKb * 1024,
-			...readProcRss(pid)
+			memory: rssKb * 1024
 		});
 	}
 	return result;
 }
+/** One pid from `/proc`, or `null` when it is gone or unreadable. */
+async function readProcPidStats(pid, uptimeSec, reader) {
+	let stat;
+	let status;
+	try {
+		[stat, status] = await Promise.all([reader.readStat(pid), reader.readStatus(pid)]);
+	} catch {
+		return null;
+	}
+	const parsed = parseProcStat(stat);
+	if (parsed === null) return null;
+	const rss = parseProcStatusRss(status);
+	if (rss.rssBytes === void 0) return null;
+	return {
+		cpu: lifetimeCpuPercent({
+			ticks: parsed.ticks,
+			startTicks: parsed.startTicks,
+			uptimeSec
+		}),
+		memory: rss.rssBytes,
+		privateBytes: rss.privateBytes,
+		sharedBytes: rss.sharedBytes
+	};
+}
+async function readProcPidStatsAll(pids, reader) {
+	const uptimeSec = await reader.readUptimeSec();
+	const entries = await Promise.all(pids.map(async (pid) => [pid, await readProcPidStats(pid, uptimeSec, reader)]));
+	const result = /* @__PURE__ */ new Map();
+	for (const [pid, stats] of entries) if (stats !== null) result.set(pid, stats);
+	return result;
+}
 /**
 * Get CPU% and memory RSS for one or more PIDs.
 * Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
 */
-async function getPidStats(pids) {
+async function getPidStats(pids, deps = defaultDeps) {
 	const pidArray = typeof pids === "number" ? [pids] : [...pids];
 	if (pidArray.length === 0) return /* @__PURE__ */ new Map();
 	try {
-		return parsePsOutput(await execPsForPids(pidArray));
+		if (deps.platform === "linux") return await readProcPidStatsAll(pidArray, deps.reader);
+		return parsePsOutput(await deps.spawnPs(pidArray));
 	} catch {
 		return /* @__PURE__ */ new Map();
 	}

package/dist/{retired-settings-keys-vK_U-CG2.mjs → retired-settings-keys-BCYUrdsA.mjs}

@@ -1,4 +1,4 @@
-import { an as asJsonObject } from "./dist-DigmGsQS.mjs";
+import { an as asJsonObject } from "./dist-Cyz5_i7z.mjs";
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/dist/{retired-settings-keys-xEAlYnv7.js → retired-settings-keys-CjvB7Etx.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-BOlMCOeT.js");
+const require_dist = require("./dist-B17W9ngu.js");
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

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

@@ -0,0 +1,92 @@
+/**
+* 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

@@ -0,0 +1,127 @@
+/**
+* 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;
+	}
+});

package/dist/wal-checkpoint-worker.js

@@ -0,0 +1,138 @@
+const require_chunk = require("./chunk-Cek0wNdY.js");
+const require_wal_checkpoint_policy = require("./wal-checkpoint-policy-CCJZngds.js");
+let node_fs = require("node:fs");
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = require_chunk.__toESM(better_sqlite3);
+let node_worker_threads = require("node:worker_threads");
+//#region src/builtins/sqlite-storage/wal-checkpoint-worker.ts
+/**
+* The checkpoint worker — a thread of `hub/sqlite-settings` whose only job is
+* `PRAGMA wal_checkpoint(PASSIVE)` over its own connection.
+*
+* Why it exists, the measurement, and the rule it follows are in
+* `wal-checkpoint-policy.ts`. What this file adds is the mechanics:
+*
+* - Its OWN connection to the same file. A checkpoint's fsyncs happen on the
+*   thread that issues the pragma; issuing it here is what takes them off the
+*   settings thread. The connection is sized to do nothing but checkpoint —
+*   a 2 MiB page cache and no mmap — so it is not a second copy of the
+*   engine's working set.
+* - PASSIVE, never FULL/RESTART/TRUNCATE. PASSIVE takes no writer lock and
+*   waits for nobody: it copies what it can and returns. The settings thread's
+*   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".
+* - Every checkpoint is reported to the parent with its numbers. The parent
+*   decides what is worth a line.
+*
+* A worker entry is a separate bundle (`dist/wal-checkpoint-worker.js`, wired
+* in `vite.config.ts` next to `addon-runner`). It imports nothing from the
+* kernel: it must load in a bare thread with `better-sqlite3` and the policy
+* module, nothing else.
+*/
+function isCheckpointRow(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("busy" in value) || !("log" in value) || !("checkpointed" in value)) return false;
+	return typeof value.busy === "number" && typeof value.log === "number" && typeof value.checkpointed === "number";
+}
+function readCheckpointRow(value) {
+	if (isCheckpointRow(value)) return value;
+	if (Array.isArray(value)) {
+		const [first] = value;
+		if (isCheckpointRow(first)) return first;
+	}
+	return null;
+}
+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);
+	}
+}
+function post(message) {
+	node_worker_threads.parentPort?.postMessage(message);
+}
+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 db = new better_sqlite3.default(dbPath);
+	db.pragma("cache_size = -2048");
+	db.pragma("mmap_size = 0");
+	let lastRunAt = Date.now();
+	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({
+				kind: "checkpointed",
+				reason: decision.reason,
+				pendingFrames: decision.pendingFrames,
+				walFrames: row.log,
+				checkpointedFrames: row.checkpointed,
+				busy: row.busy !== 0,
+				ms: lastRunAt - startedAt
+			});
+		}
+		timer = setTimeout(tick, pollMs);
+	};
+	port.on("message", (message) => {
+		if (!require_wal_checkpoint_policy.isWorkerStop(message)) return;
+		stopping = true;
+		if (timer !== null) clearTimeout(timer);
+		try {
+			db.close();
+		} finally {
+			port.close();
+		}
+	});
+	post({ kind: "ready" });
+	timer = setTimeout(tick, pollMs);
+}
+run();
+//#endregion