@camstack/system 1.2.218 → 1.2.220

package/dist/wal-checkpoint-worker.mjs

@@ -0,0 +1,137 @@
+import { a as isWorkerStop, o as parseWalIndexHeader, r as decideCheckpoint } from "./wal-checkpoint-policy-CAcg63o-.mjs";
+import { closeSync, openSync, readSync } from "node:fs";
+import Database from "better-sqlite3";
+import { parentPort, workerData } from "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 = 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);
+	}
+}
+function post(message) {
+	parentPort?.postMessage(message);
+}
+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 db = new Database(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 = 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 (!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
+export {};

package/package.json

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

package/dist/{event-loop-stall-monitor-DM9OAzy8.js → event-loop-stall-monitor-CAsHdMwP.js}

@@ -2,9 +2,9 @@ const require_chunk = require("./chunk-Cek0wNdY.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
-let node_util = require("node:util");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
+let node_util = require("node:util");
 let node_http = require("node:http");
 let node_zlib = require("node:zlib");
 let node_perf_hooks = require("node:perf_hooks");

package/dist/{event-loop-stall-monitor-B3CFd9tM.mjs → event-loop-stall-monitor-GPrVvx14.mjs}

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import * as path$1 from "node:path";
 import path from "node:path";
-import { promisify } from "node:util";
 import * as fs from "node:fs";
 import { createReadStream, promises } from "node:fs";
+import { promisify } from "node:util";
 import { createServer } from "node:http";
 import { brotliCompress, constants as constants$1, gzip } from "node:zlib";
 import { PerformanceObserver } from "node:perf_hooks";

package/dist/{tls-DOTmtLCW.mjs → tls-2xbgg78V.mjs}

@@ -1,11 +1,11 @@
 import { X509Certificate, createPrivateKey, randomBytes } from "node:crypto";
 import { chmod, copyFile, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { execFile } from "node:child_process";
 import * as os from "node:os";
 import { tmpdir } from "node:os";
+import { promisify } from "node:util";
 import { createServer } from "node:http";
 import { isIP } from "node:net";
 //#region src/http/lan-http-bind.ts

package/dist/{tls-BxQlomxd.js → tls-BFs4PzoW.js}

@@ -2,11 +2,11 @@ const require_chunk = require("./chunk-Cek0wNdY.js");
 let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
-let node_child_process = require("node:child_process");
-let node_util = require("node:util");
 let node_fs = require("node:fs");
+let node_child_process = require("node:child_process");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
+let node_util = require("node:util");
 let node_http = require("node:http");
 let node_net = require("node:net");
 //#region src/http/lan-http-bind.ts