glimmervoid 0.30.0 → 0.32.0

package/dist/chunks/git-version-CrLW4a6r.js

@@ -0,0 +1,58 @@
+import { r as execFileSync } from "./child-process-safe-DDELk9XC.js";
+//#region server/core/git-version-core.ts
+var NEW_WORK_ISOLATION_FLOOR = Object.freeze({
+	major: 2,
+	minor: 48
+});
+var NEW_WORK_ISOLATION_FLOOR_LABEL = `${NEW_WORK_ISOLATION_FLOOR.major}.${NEW_WORK_ISOLATION_FLOOR.minor}`;
+var WHOLE_RANGE_CONSEQUENCE = "a team re-review cannot single out the author's new work and reviews the whole pull request range";
+var GIT_UPDATE_HINT = `Update git to ${NEW_WORK_ISOLATION_FLOOR_LABEL} or newer`;
+var UNKNOWN_GIT_VERSION = Object.freeze({
+	version: null,
+	isTooOldToIsolateNewWork: false
+});
+function gitVersionReport(versionOutput) {
+	const match = /^git version (\d+)\.(\d+)(?:\.(\d+))?/.exec(versionOutput?.trim() ?? "");
+	if (!match) return UNKNOWN_GIT_VERSION;
+	const [, major = "", minor = "", patch] = match;
+	const isBelowFloorMajor = Number(major) < NEW_WORK_ISOLATION_FLOOR.major;
+	const isBelowFloorMinor = Number(major) === NEW_WORK_ISOLATION_FLOOR.major && Number(minor) < NEW_WORK_ISOLATION_FLOOR.minor;
+	return {
+		version: [
+			major,
+			minor,
+			patch
+		].filter((part) => part !== void 0).join("."),
+		isTooOldToIsolateNewWork: isBelowFloorMajor || isBelowFloorMinor
+	};
+}
+function gitBootWarning(report) {
+	if (!report.isTooOldToIsolateNewWork) return null;
+	return `[git] git ${report.version} is older than ${NEW_WORK_ISOLATION_FLOOR_LABEL}, so ${WHOLE_RANGE_CONSEQUENCE}. ${GIT_UPDATE_HINT}.`;
+}
+function gitDoctorRows(report) {
+	const versionRow = ["git", report.version ?? "unknown"];
+	if (!report.isTooOldToIsolateNewWork) return [versionRow];
+	return [versionRow, ["hint", `${GIT_UPDATE_HINT}: on an older one ${WHOLE_RANGE_CONSEQUENCE}`]];
+}
+//#endregion
+//#region server/git-version.ts
+function readGitVersionOutput() {
+	return execFileSync("git", ["--version"], {
+		encoding: "utf8",
+		timeout: 3e3
+	});
+}
+function probeGitVersion({ readVersionOutput = readGitVersionOutput } = {}) {
+	try {
+		return gitVersionReport(readVersionOutput());
+	} catch {
+		return gitVersionReport(null);
+	}
+}
+function warnWhenGitIsTooOld({ probe = probeGitVersion, log = console } = {}) {
+	const warning = gitBootWarning(probe());
+	if (warning !== null) log.warn(warning);
+}
+//#endregion
+export { warnWhenGitIsTooOld as n, gitDoctorRows as r, probeGitVersion as t };

package/dist/chunks/{grok-DuU8xVLZ.js → grok-C4lzPFEg.js}

@@ -1,12 +1,19 @@
-import { o as relayPath } from "./runtime-paths-Ci_ksSkj.js";
-import { n as AGENT_URL_ENV } from "./session-Cez8aIWg.js";
-import { t as HOOK_URL_ENV } from "./hook-relay-core-BHfYFnYV.js";
-import { a as SANE_YOLO_PATH_ENV, n as RTK_PATH_ENV, o as saneYoloEnv } from "./rtk-hook-core-Bl6gYHPN.js";
+import { r as errorMessage } from "./text-DoirglWV.js";
+import { o as relayPath } from "./runtime-paths-BPoxENmK.js";
+import { n as AGENT_URL_ENV } from "./session-B8fJb_Or.js";
+import { t as HOOK_URL_ENV } from "./hook-relay-core-DA_bz2KA.js";
+import { n as isRecord } from "./coerce-NSst8oRP.js";
+import { a as SANE_YOLO_PATH_ENV, n as RTK_PATH_ENV, o as saneYoloEnv } from "./rtk-hook-core-BmEz2aq9.js";
 import { t as buildHookCommand } from "./hook-command-core-DclEoE9e.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 //#region session/core/spawn-env.ts
+var GLIMMERVOID_SECRET_KEYS = [
+	"GLIMMERVOID_POSTHOG_API_KEY",
+	"GLIMMERVOID_TELEGRAM_BOT_TOKEN",
+	"GLIMMERVOID_CLAUDE_OAUTH_TOKEN"
+];
 var GLIMMERVOID_SCRUB_KEYS = [
 	"GLIMMERVOID_PORT",
 	"GLIMMERVOID_CONFIG",
@@ -14,11 +21,7 @@ var GLIMMERVOID_SCRUB_KEYS = [
 	AGENT_URL_ENV,
 	RTK_PATH_ENV,
 	SANE_YOLO_PATH_ENV,
-	...[
-		"GLIMMERVOID_POSTHOG_API_KEY",
-		"GLIMMERVOID_TELEGRAM_BOT_TOKEN",
-		"GLIMMERVOID_CLAUDE_OAUTH_TOKEN"
-	]
+	...GLIMMERVOID_SECRET_KEYS
 ];
 var SANE_YOLO_GUARD_KEYS = [SANE_YOLO_PATH_ENV, ...Object.keys(saneYoloEnv(""))];
 var SAFETY_NET_ENV_PREFIXES = ["CC_SAFETY_NET_", "SAFETY_NET_"];
@@ -68,7 +71,7 @@ function isSaneYoloGuarded(extraEnv) {
 function scrubInheritedSafetyNetEnv(env) {
 	for (const key of Object.keys(env)) if (isSafetyNetKey(key)) delete env[key];
 }
-function buildAgentEnv(baseEnv, extraEnv, profile, { prependPathDir: pathDir = null } = {}) {
+function buildAgentEnv(baseEnv, extraEnv, profile, { prependPathDir: pathDir = null, prependPathDirs = [] } = {}) {
 	const env = { ...baseEnv };
 	for (const key of profile.scrub || []) delete env[key];
 	for (const key of GLIMMERVOID_SCRUB_KEYS) delete env[key];
@@ -77,6 +80,8 @@ function buildAgentEnv(baseEnv, extraEnv, profile, { prependPathDir: pathDir = n
 	Object.assign(env, extraEnv || {});
 	Object.assign(env, profile.set || {});
 	prependPathDir(env, pathDir);
+	const uniquePathDirs = prependPathDirs.filter((directory, index) => prependPathDirs.findIndex((candidate) => normalizePathEntry(candidate) === normalizePathEntry(directory)) === index);
+	for (const directory of uniquePathDirs.reverse()) prependPathDir(env, directory);
 	return env;
 }
 //#endregion
@@ -102,7 +107,7 @@ function renderGrokHooksFile({ relayPath, events, hookToolRelayPath }) {
 	return `${JSON.stringify({ hooks }, null, 2)}\n`;
 }
 function hasOnlyKeys(value, expectedKeys) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	if (!isRecord(value)) return false;
 	const actualKeys = Object.keys(value).sort();
 	const sortedExpectedKeys = [...expectedKeys].sort();
 	return actualKeys.length === sortedExpectedKeys.length && actualKeys.every((key, index) => key === sortedExpectedKeys[index]);
@@ -150,7 +155,7 @@ function classifyGrokHooksFile(contents, { relayPath, events, managedEventSets =
 	if (!hasOnlyKeys(parsed, ["hooks"])) return "foreign";
 	const hooksValue = parsed.hooks;
 	if (hooksValue === null || hooksValue === void 0) throw new TypeError("hooks must be an object");
-	if (typeof hooksValue !== "object" || Array.isArray(hooksValue)) return "foreign";
+	if (!isRecord(hooksValue)) return "foreign";
 	const actualEvents = Object.keys(hooksValue);
 	if (!hasOnlyKeys(hooksValue, actualEvents)) return "foreign";
 	const hooks = hooksValue;
@@ -235,15 +240,14 @@ function isMainSessionPayload(payload) {
 	return !payload?.subagentType && !payload?.subagent_type;
 }
 function mapBackgroundTask(task) {
-	if (!task || typeof task !== "object" || Array.isArray(task)) return task;
-	const entry = task;
+	if (!isRecord(task)) return task;
 	return {
-		...entry,
-		...typeof entry.agentType === "string" ? { agent_type: entry.agentType } : {}
+		...task,
+		...typeof task.agentType === "string" ? { agent_type: task.agentType } : {}
 	};
 }
 function mapHookPayload(_event, payload) {
-	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return payload;
+	if (!isRecord(payload)) return payload;
 	return {
 		...payload,
 		...typeof payload.subagentId === "string" ? { agent_id: payload.subagentId } : {},
@@ -259,7 +263,7 @@ function mayContributeHooks(configText) {
 	} catch {
 		return true;
 	}
-	if (!settings || typeof settings !== "object" || Array.isArray(settings)) return false;
+	if (!isRecord(settings)) return false;
 	return Object.hasOwn(settings, "hooks");
 }
 function mapHookToSignal(event, payload) {
@@ -337,7 +341,7 @@ function resolveCommand({ platform = process.platform, env = process.env, homedi
 			kind: "exe"
 		};
 	} catch (error) {
-		warn(`[glimmervoid] could not resolve the native 'grok' binary at ${candidate}: ${error instanceof Error ? error.message : String(error)}`);
+		warn(`[glimmervoid] could not resolve the native 'grok' binary at ${candidate}: ${errorMessage(error)}`);
 		return {
 			path: null,
 			kind: "unresolved"
@@ -426,11 +430,10 @@ var grok = {
 		statusLine: false,
 		rtk: false,
 		saneYolo: true,
-		antiSlop: false,
 		compactQuiet: false,
 		skipPermissionsFlag: true,
 		headless: true
 	}
 };
 //#endregion
-export { classifyGrokHooksFile as a, isSpinnerChar as i, classifyAgentTitle as n, renderGrokHooksFile as o, isBrailleChar as r, buildAgentEnv as s, grok as t };
+export { classifyGrokHooksFile as a, buildAgentEnv as c, isSpinnerChar as i, classifyAgentTitle as n, renderGrokHooksFile as o, isBrailleChar as r, GLIMMERVOID_SECRET_KEYS as s, grok as t };

package/dist/chunks/{hook-relay-core-BHfYFnYV.js → hook-relay-core-DA_bz2KA.js}

@@ -1,12 +1,17 @@
-//#region session/core/hook-relay-core.ts
-var HOOK_URL_ENV = "GLIMMERVOID_HOOK_URL";
-var MAX_RESPONSE_BYTES = 65536;
+//#region shared/loopback-hosts.ts
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
 	"127.0.0.1",
 	"::1",
 	"[::1]",
 	"localhost"
 ]);
+function isLoopbackHostname(hostname) {
+	return LOOPBACK_HOSTS.has(hostname);
+}
+//#endregion
+//#region session/core/hook-relay-core.ts
+var HOOK_URL_ENV = "GLIMMERVOID_HOOK_URL";
+var MAX_RESPONSE_BYTES = 65536;
 var EVENT_RE = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
 var HOOK_PATH_PREFIX = "/hook/";
 function readHookUrl(env) {
@@ -34,7 +39,7 @@ function resolveHookTarget(baseUrl, event, pathPrefix = HOOK_PATH_PREFIX) {
 		url: null,
 		reason: "not-http"
 	};
-	if (!LOOPBACK_HOSTS.has(target.hostname)) return {
+	if (!isLoopbackHostname(target.hostname)) return {
 		url: null,
 		reason: "not-loopback"
 	};
@@ -85,4 +90,4 @@ function decideRelayPost({ env = {}, event = null, payloadBytes = 0 } = {}) {
 	};
 }
 //#endregion
-export { resolveHookTarget as i, MAX_RESPONSE_BYTES as n, decideRelayPost as r, HOOK_URL_ENV as t };
+export { isLoopbackHostname as a, resolveHookTarget as i, MAX_RESPONSE_BYTES as n, decideRelayPost as r, HOOK_URL_ENV as t };

package/dist/chunks/{hook-tools-pSJia7ks.js → hook-tools-UX2fmt81.js}

@@ -1,5 +1,5 @@
 import { r as resolvePathCommandMatches } from "./spawn-command-Cc40FiZI.js";
-import { a as SANE_YOLO_PATH_ENV, n as RTK_PATH_ENV, o as saneYoloEnv } from "./rtk-hook-core-Bl6gYHPN.js";
+import { a as SANE_YOLO_PATH_ENV, n as RTK_PATH_ENV, o as saneYoloEnv } from "./rtk-hook-core-BmEz2aq9.js";
 import { t as buildHookCommand } from "./hook-command-core-DclEoE9e.js";
 import path from "node:path";
 //#region session/core/hook-tools.ts
@@ -12,12 +12,10 @@ function firstExistingFile(candidates, fsApi) {
 function resolveRtkPath({ glimmervoidHome, platform, exec, fsApi }) {
 	const bundled = firstExistingFile([path.join(glimmervoidHome, "bin", "rtk.exe"), path.join(glimmervoidHome, "bin", "rtk")], fsApi);
 	if (bundled) return bundled;
-	const matches = resolvePathCommandMatches("rtk", {
+	const firstMatch = resolvePathCommandMatches("rtk", {
 		platform,
 		exec
-	});
-	if (matches.length === 0) return null;
-	const firstMatch = matches[0];
+	})[0];
 	if (!firstMatch) return null;
 	return path.resolve(firstMatch);
 }

package/dist/chunks/{ingest-editor-core-BuI1gMF_.js → ingest-editor-core-vR6Wv6bP.js}

@@ -1,3 +1,4 @@
+import { a as isPathInside } from "./paths-CeJl2Vcg.js";
 //#region server/core/visions-buffer-core.ts
 function createDocStore() {
 	return { docsByUri: Object.create(null) };
@@ -317,12 +318,7 @@ function pathOfFileUri(uri) {
 	return normalizeShapePath(pathname);
 }
 function isWithin(scopePath, uriPath, foldCase = false) {
-	if (!scopePath || !uriPath) return false;
-	const scopeKey = foldCase ? scopePath.toLowerCase() : scopePath;
-	const uriKey = foldCase ? uriPath.toLowerCase() : uriPath;
-	if (uriKey === scopeKey) return true;
-	const prefix = scopeKey.endsWith("/") ? scopeKey : `${scopeKey}/`;
-	return uriKey.startsWith(prefix);
+	return isPathInside(scopePath, uriPath, { foldCase });
 }
 function isUriInProjects(uri, normalizedProjectPaths, foldCase = false) {
 	const uriPath = pathOfFileUri(uri);
@@ -361,23 +357,38 @@ function scopePathsOf(scopeProjects) {
 	return paths;
 }
 function resolveVisionsScopeProjects({ configuredIds, projects, warn }) {
+	const ids = Array.isArray(configuredIds) ? configuredIds.filter((id) => typeof id === "string" && id !== "") : [];
+	const wanted = new Set(ids);
 	const usable = [];
+	const usableIds = /* @__PURE__ */ new Set();
 	const seenPaths = /* @__PURE__ */ new Set();
 	for (const project of Array.isArray(projects) ? projects : []) {
 		if (!project || typeof project.id !== "string" || project.id === "") continue;
+		if (wanted.size > 0 && !wanted.has(project.id)) continue;
 		const normalizedPath = normalizeShapePath(project.path);
-		if (!normalizedPath || seenPaths.has(normalizedPath)) continue;
+		if (!normalizedPath) continue;
+		usableIds.add(project.id);
+		if (seenPaths.has(normalizedPath)) continue;
 		seenPaths.add(normalizedPath);
 		usable.push({
 			id: project.id,
 			path: normalizedPath
 		});
 	}
-	const ids = Array.isArray(configuredIds) ? configuredIds.filter((id) => typeof id === "string" && id !== "") : [];
-	if (ids.length === 0) return usable;
-	const wanted = new Set(ids);
-	for (const id of ids) if (!usable.some((project) => project.id === id)) warn(`[visions] configured project id not found or has no usable path: ${id}`);
-	return usable.filter((project) => wanted.has(project.id));
+	for (const id of ids) if (!usableIds.has(id)) warn(`[visions] configured project id not found or has no usable path: ${id}`);
+	return usable;
+}
+function visionsLaneReloadSignature(ingest, visions, projects) {
+	const scopeProjects = visions.enabled ? resolveVisionsScopeProjects({
+		configuredIds: visions.projects,
+		projects,
+		warn: () => {}
+	}) : [];
+	return JSON.stringify({
+		ingest,
+		visions,
+		scopeProjects
+	});
 }
 //#endregion
 //#region server/core/ingest-editor-core.ts
@@ -442,4 +453,4 @@ function applyEditorNotification(state, { method, uri, roots = [], foldCase = fa
 	};
 }
 //#endregion
-export { listDocs as _, projectForUri as a, uriOfParams as b, applyDidChange as c, createDocStore as d, detectBlankLineBoundary as f, lineStartOffsets as g, lineOfOffset as h, isUriInProjects as i, applyDidClose as l, getDoc as m, applyEditorNotification as n, resolveVisionsScopeProjects as o, formatRange as p, createEditorState as r, scopePathsOf as s, ACTIVITY_METHOD as t, applyDidOpen as u, offsetOfPosition as v, replacedSpanOfWholeTextChange as y };
+export { lineStartOffsets as _, projectForUri as a, replacedSpanOfWholeTextChange as b, visionsLaneReloadSignature as c, applyDidOpen as d, createDocStore as f, lineOfOffset as g, getDoc as h, isUriInProjects as i, applyDidChange as l, formatRange as m, applyEditorNotification as n, resolveVisionsScopeProjects as o, detectBlankLineBoundary as p, createEditorState as r, scopePathsOf as s, ACTIVITY_METHOD as t, applyDidClose as u, listDocs as v, uriOfParams as x, offsetOfPosition as y };

package/dist/chunks/json-core-dfa_7Fak.js

@@ -0,0 +1,23 @@
+import { n as isRecord } from "./coerce-NSst8oRP.js";
+//#region server/core/json-core.ts
+function jsonSourceText(text) {
+	if (typeof text === "string") return text;
+	if (Buffer.isBuffer(text)) return text.toString("utf8");
+	return null;
+}
+function parseJsonOrNull(text) {
+	const source = jsonSourceText(text);
+	if (source === null) return null;
+	try {
+		return JSON.parse(source);
+	} catch {
+		return null;
+	}
+}
+function parseJsonRecord(text, { admitArrays = false } = {}) {
+	const parsed = parseJsonOrNull(text);
+	if (admitArrays) return parsed !== null && typeof parsed === "object" ? parsed : null;
+	return isRecord(parsed) ? parsed : null;
+}
+//#endregion
+export { parseJsonRecord as n, parseJsonOrNull as t };

package/dist/chunks/json-file-oEH9vt-0.js

@@ -0,0 +1,352 @@
+import { a as isMissingFileError, r as errorMessage } from "./text-DoirglWV.js";
+import { r as nextBackoffMs } from "./backoff-DjVpfHk7.js";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region server/spawn-gate.ts
+var QUEUE_ADMISSION_TIMED_OUT = "serial-queue-admission-timed-out";
+function isQueueAdmissionTimeout(error) {
+	return error instanceof Error && error.message === "serial-queue-admission-timed-out";
+}
+function createSerialQueue() {
+	let tail = Promise.resolve();
+	function run(fn, options = {}) {
+		let abandoned = false;
+		let started = false;
+		const result = tail.then(() => {
+			if (abandoned) throw new Error(QUEUE_ADMISSION_TIMED_OUT);
+			started = true;
+			return fn();
+		});
+		tail = result.then(() => void 0, () => void 0);
+		const admissionTimeoutMs = options.admissionTimeoutMs;
+		if (admissionTimeoutMs === void 0) return result;
+		return new Promise((resolve, reject) => {
+			const admissionTimer = setTimeout(() => {
+				if (started) return;
+				abandoned = true;
+				reject(/* @__PURE__ */ new Error(QUEUE_ADMISSION_TIMED_OUT));
+			}, admissionTimeoutMs);
+			result.then((value) => {
+				clearTimeout(admissionTimer);
+				resolve(value);
+			}, (error) => {
+				clearTimeout(admissionTimer);
+				reject(error);
+			});
+		});
+	}
+	return {
+		run,
+		idle: () => tail
+	};
+}
+function createKeyedSerialQueue() {
+	const queuesByKey = /* @__PURE__ */ new Map();
+	function run(key, fn) {
+		const entry = queuesByKey.get(key) ?? {
+			queue: createSerialQueue(),
+			pendingCount: 0
+		};
+		queuesByKey.set(key, entry);
+		entry.pendingCount += 1;
+		const result = entry.queue.run(fn);
+		result.then(() => void 0, () => void 0).then(() => {
+			entry.pendingCount -= 1;
+			if (entry.pendingCount === 0 && queuesByKey.get(key) === entry) queuesByKey.delete(key);
+		});
+		return result;
+	}
+	return { run };
+}
+var createSpawnGate = createSerialQueue;
+//#endregion
+//#region server/json-file.ts
+function tmpPathFor(filePath) {
+	return `${filePath}.${process.pid}.${crypto.randomBytes(8).toString("hex")}.tmp`;
+}
+function writeOptions(mode, encoding, exclusive) {
+	return {
+		encoding,
+		...mode == null ? {} : { mode },
+		...exclusive ? { flag: "wx" } : {}
+	};
+}
+var RENAME_RETRY_CODES = /* @__PURE__ */ new Set([
+	"EPERM",
+	"EACCES",
+	"EBUSY"
+]);
+var RENAME_RETRY_BASE_MS = 10;
+var RENAME_RETRY_MAX_MS = 50;
+function renameRetryDelayMs(attempt) {
+	return nextBackoffMs({
+		attempt: attempt + 1,
+		baseMs: RENAME_RETRY_BASE_MS,
+		maxMs: RENAME_RETRY_MAX_MS,
+		jitter: "none"
+	});
+}
+function isRetryableRename(error, attempt) {
+	if (attempt >= 4) return false;
+	const code = error?.code;
+	return typeof code === "string" && RENAME_RETRY_CODES.has(code);
+}
+function sleepSync(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function renameRetryPlan(error, attempt) {
+	if (!isRetryableRename(error, attempt)) return null;
+	return renameRetryDelayMs(attempt);
+}
+function decodeJsonState(text, parse) {
+	try {
+		const value = parse(JSON.parse(text));
+		if (value !== null) return { value };
+		return { error: /* @__PURE__ */ new Error("the parser rejected the file content") };
+	} catch (error) {
+		return { error };
+	}
+}
+async function loadJsonStateFile({ filePath, fsPromises = fs.promises, parse, nowMs = Date.now, quarantine = true, includeNotDir = true }) {
+	let text;
+	try {
+		text = await fsPromises.readFile(filePath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error, { includeNotDir })) return { status: "missing" };
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	const decoded = decodeJsonState(text, parse);
+	if ("value" in decoded) return {
+		status: "loaded",
+		value: decoded.value
+	};
+	if (!quarantine || !fsPromises.rename) return {
+		status: "corrupt",
+		error: decoded.error
+	};
+	const movedTo = `${filePath}.corrupt-${nowMs()}`;
+	try {
+		await fsPromises.rename(filePath, movedTo);
+	} catch (error) {
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	return {
+		status: "quarantined",
+		movedTo
+	};
+}
+function loadJsonStateFileSync({ filePath, fsSync = fs, parse, nowMs = Date.now, quarantine = true, includeNotDir = true }) {
+	let text;
+	try {
+		text = fsSync.readFileSync(filePath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error, { includeNotDir })) return { status: "missing" };
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	const decoded = decodeJsonState(text, parse);
+	if ("value" in decoded) return {
+		status: "loaded",
+		value: decoded.value
+	};
+	if (!quarantine || !fsSync.renameSync) return {
+		status: "corrupt",
+		error: decoded.error
+	};
+	const movedTo = `${filePath}.corrupt-${nowMs()}`;
+	try {
+		fsSync.renameSync(filePath, movedTo);
+	} catch (error) {
+		return {
+			status: "unreadable",
+			error
+		};
+	}
+	return {
+		status: "quarantined",
+		movedTo
+	};
+}
+function loadedJsonValue(outcome) {
+	return outcome.status === "loaded" ? outcome.value : null;
+}
+function jsonStateLoadError(outcome) {
+	if ("error" in outcome) return outcome.error;
+	return /* @__PURE__ */ new Error(`the state file is ${outcome.status}`);
+}
+function renameWithRetrySync(fsSync, tmpPath, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		fsSync.renameSync(tmpPath, filePath);
+		return;
+	} catch (error) {
+		const delayMs = renameRetryPlan(error, attempt);
+		if (delayMs === null) throw error;
+		sleepSync(delayMs);
+	}
+}
+async function renameWithRetry(fsPromises, tmpPath, filePath) {
+	for (let attempt = 0;; attempt += 1) try {
+		await fsPromises.rename(tmpPath, filePath);
+		return;
+	} catch (error) {
+		const delayMs = renameRetryPlan(error, attempt);
+		if (delayMs === null) throw error;
+		await new Promise((resolve) => {
+			setTimeout(resolve, delayMs);
+		});
+	}
+}
+function mkdirSyncOf(fsSync) {
+	if (!fsSync.mkdirSync) throw new Error("the file system cannot create directories");
+	return fsSync.mkdirSync;
+}
+function mkdirOf(fsPromises) {
+	if (!fsPromises.mkdir) throw new Error("the file system cannot create directories");
+	return fsPromises.mkdir;
+}
+function appendFileOf(fsPromises) {
+	if (!fsPromises.appendFile) throw new Error("the file system cannot append to files");
+	return fsPromises.appendFile;
+}
+function writeTextAtomicSync(filePath, content, { mode, encoding = "utf8", mkdir = false, exclusive = false, enforceMode = false, fsSync = fs } = {}) {
+	if (mkdir) mkdirSyncOf(fsSync)(path.dirname(filePath), { recursive: true });
+	const tmpPath = tmpPathFor(filePath);
+	try {
+		fsSync.writeFileSync(tmpPath, content, writeOptions(mode, encoding, exclusive));
+		renameWithRetrySync(fsSync, tmpPath, filePath);
+	} catch (error) {
+		try {
+			fsSync.rmSync(tmpPath, { force: true });
+		} catch {}
+		throw error;
+	}
+	if (!enforceMode || mode == null || !fsSync.chmodSync) return;
+	try {
+		fsSync.chmodSync(filePath, mode);
+	} catch {}
+}
+function writeJsonAtomicSync(filePath, value, options) {
+	writeTextAtomicSync(filePath, JSON.stringify(value, null, 2), options);
+}
+async function writeTextAtomic(filePath, content, { mode, encoding = "utf8", mkdir = false, exclusive = false, enforceMode = false, fsPromises = fs.promises } = {}) {
+	if (mkdir) await mkdirOf(fsPromises)(path.dirname(filePath), { recursive: true });
+	const tmpPath = tmpPathFor(filePath);
+	try {
+		await fsPromises.writeFile(tmpPath, content, writeOptions(mode, encoding, exclusive));
+		await renameWithRetry(fsPromises, tmpPath, filePath);
+	} catch (error) {
+		try {
+			await fsPromises.rm(tmpPath, { force: true });
+		} catch {}
+		throw error;
+	}
+	if (!enforceMode || mode == null || !fsPromises.chmod) return;
+	try {
+		await fsPromises.chmod(filePath, mode);
+	} catch {}
+}
+async function writeJsonAtomic(filePath, value, options) {
+	await writeTextAtomic(filePath, JSON.stringify(value, null, 2), options);
+}
+var appendQueue = createKeyedSerialQueue();
+function appendChained(filePath, payload, { fsPromises = fs.promises, mkdir = false, encoding = "utf8", mode } = {}) {
+	return appendQueue.run(filePath, async () => {
+		if (mkdir) await mkdirOf(fsPromises)(path.dirname(filePath), { recursive: true });
+		await appendFileOf(fsPromises)(filePath, payload, writeOptions(mode, encoding, false));
+	});
+}
+function appendJsonLine(filePath, value, options) {
+	return appendChained(filePath, `${JSON.stringify(value)}\n`, options);
+}
+function appendJsonLines(filePath, values, options) {
+	if (values.length === 0) return Promise.resolve();
+	return appendChained(filePath, values.map((value) => `${JSON.stringify(value)}\n`).join(""), options);
+}
+function createJsonStateWriter({ filePath, fsPromises = fs.promises, warn = () => {} }) {
+	let signature = null;
+	const writeQueue = createSerialQueue();
+	async function commit(payload) {
+		try {
+			await writeTextAtomic(filePath, payload, {
+				fsPromises,
+				mkdir: true
+			});
+		} catch (error) {
+			warn(error);
+			signature = null;
+		}
+	}
+	async function write(subject, buildPayload) {
+		const next = JSON.stringify(subject);
+		if (next === signature) return;
+		signature = next;
+		await writeQueue.run(() => commit(buildPayload())).catch(() => {});
+	}
+	function reset() {
+		signature = null;
+	}
+	return {
+		write,
+		reset,
+		idle: () => writeQueue.idle()
+	};
+}
+function createJsonStateStore({ name, filePath, fsPromises = fs.promises, parse, adopt, nowMs = Date.now, warn = () => {} }) {
+	const writer = filePath ? createJsonStateWriter({
+		filePath,
+		fsPromises,
+		warn: (error) => warn(`${name} write failed`, { error: errorMessage(error) })
+	}) : null;
+	let isFileReadable = true;
+	let loadPromise = null;
+	function load() {
+		const statePath = filePath;
+		if (!statePath) return Promise.resolve();
+		if (loadPromise) return loadPromise;
+		loadPromise = (async () => {
+			const outcome = await loadJsonStateFile({
+				filePath: statePath,
+				fsPromises,
+				parse,
+				nowMs
+			});
+			if (outcome.status === "unreadable" || outcome.status === "corrupt") {
+				isFileReadable = false;
+				loadPromise = null;
+				warn(`${name} unreadable`, {
+					path: statePath,
+					error: errorMessage(outcome.error)
+				});
+				return;
+			}
+			if (outcome.status === "quarantined") warn(`${name} quarantined`, {
+				path: statePath,
+				movedTo: outcome.movedTo
+			});
+			isFileReadable = true;
+			adopt(loadedJsonValue(outcome));
+			writer?.reset();
+		})();
+		return loadPromise;
+	}
+	async function write(subject, buildPayload) {
+		if (!writer || !isFileReadable) return;
+		await writer.write(subject, buildPayload);
+	}
+	return {
+		load,
+		write,
+		idle: () => writer ? writer.idle() : Promise.resolve()
+	};
+}
+//#endregion
+export { isQueueAdmissionTimeout as _, jsonStateLoadError as a, loadedJsonValue as c, writeJsonAtomicSync as d, writeTextAtomic as f, createSpawnGate as g, createSerialQueue as h, createJsonStateWriter as i, sleepSync as l, createKeyedSerialQueue as m, appendJsonLines as n, loadJsonStateFile as o, writeTextAtomicSync as p, createJsonStateStore as r, loadJsonStateFileSync as s, appendJsonLine as t, writeJsonAtomic as u };