glimmervoid 0.37.0 → 0.38.0

package/dist/chunks/{json-file-BaxGcB2R.js → json-file-CIJf0Cel.js}

@@ -3,11 +3,60 @@ 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/core/memory-admission-core.ts
+var BYTES_PER_MEGABYTE$1 = 1048576;
+var MEMORY_RECHECK_MS = 5e3;
+var MEMORY_RESERVATION_SETTLE_MS = 3e4;
+var DEFAULT_CHECK_MEMORY_RESERVE_MB = 1500;
+function memoryReserveBytes(config, kind) {
+	return (kind === "session" ? config.sessionMemoryReserveMB ?? 600 : config.checkMemoryReserveMB ?? 1500) * BYTES_PER_MEGABYTE$1;
+}
+function parseCgroupV2Path(procSelfCgroupText) {
+	const unifiedLine = procSelfCgroupText.split("\n").find((line) => line.startsWith("0::"));
+	if (unifiedLine === void 0) return null;
+	const cgroupPath = unifiedLine.slice(3).trim();
+	return cgroupPath.startsWith("/") ? cgroupPath : null;
+}
+function cgroupAncestorPaths(cgroupPath) {
+	const segments = cgroupPath.split("/").filter((segment) => segment.length > 0);
+	return segments.map((_segment, depthFromLeaf) => `/${segments.slice(0, segments.length - depthFromLeaf).join("/")}`);
+}
+function parseCgroupBytes(text) {
+	if (text === null) return null;
+	const trimmed = text.trim();
+	return /^\d+$/.test(trimmed) ? Number(trimmed) : null;
+}
+function cgroupLimitBytes(memoryHighText, memoryMaxText) {
+	return parseCgroupBytes(memoryHighText) ?? parseCgroupBytes(memoryMaxText);
+}
+function parseMemAvailableBytes(meminfoText) {
+	const match = /^MemAvailable:\s+(\d+)\s+kB$/m.exec(meminfoText);
+	return match ? Number(match[1]) * 1024 : null;
+}
+function headroomFromReadings({ cgroupLevels, hostAvailableBytes }) {
+	const candidates = cgroupLevels.flatMap(({ limitBytes, currentBytes }) => limitBytes === null || currentBytes === null ? [] : [Math.max(0, limitBytes - currentBytes)]);
+	if (hostAvailableBytes !== null) candidates.push(hostAvailableBytes);
+	return candidates.length === 0 ? null : Math.min(...candidates);
+}
+function liveReservations(reservations, nowMs) {
+	return reservations.filter((reservation) => nowMs - reservation.admittedAtMs < MEMORY_RESERVATION_SETTLE_MS);
+}
+function shouldAdmitStart({ reading, reserveBytes, reservations, nowMs }) {
+	if (!reading.ok) return true;
+	const reservedBytes = liveReservations(reservations, nowMs).reduce((total, reservation) => total + reservation.bytes, 0);
+	return reading.headroomBytes - reservedBytes >= reserveBytes;
+}
+//#endregion
 //#region server/spawn-gate.ts
+var BYTES_PER_MEGABYTE = 1048576;
 var QUEUE_ADMISSION_TIMED_OUT = "serial-queue-admission-timed-out";
+var QUEUE_ADMISSION_ABANDONED = "serial-queue-admission-abandoned";
 function isQueueAdmissionTimeout(error) {
 	return error instanceof Error && error.message === QUEUE_ADMISSION_TIMED_OUT;
 }
+function isQueueAdmissionAbandoned(error) {
+	return error instanceof Error && error.message === QUEUE_ADMISSION_ABANDONED;
+}
 function createSerialQueue() {
 	let tail = Promise.resolve();
 	function run(fn, options = {}) {
@@ -19,19 +68,27 @@ function createSerialQueue() {
 			return fn();
 		});
 		tail = result.then(() => void 0, () => void 0);
-		const admissionTimeoutMs = options.admissionTimeoutMs;
-		if (admissionTimeoutMs === void 0) return result;
+		const { admissionTimeoutMs, signal } = options;
+		if (admissionTimeoutMs === void 0 && signal === void 0) return result;
 		return new Promise((resolve, reject) => {
-			const admissionTimer = setTimeout(() => {
+			const leaveUnlessStarted = (reason) => {
 				if (started) return;
 				abandoned = true;
-				reject(/* @__PURE__ */ new Error(QUEUE_ADMISSION_TIMED_OUT));
-			}, admissionTimeoutMs);
-			result.then((value) => {
+				reject(new Error(reason));
+			};
+			const admissionTimer = admissionTimeoutMs === void 0 ? void 0 : setTimeout(() => leaveUnlessStarted(QUEUE_ADMISSION_TIMED_OUT), admissionTimeoutMs);
+			const leaveOnAbort = () => leaveUnlessStarted(QUEUE_ADMISSION_ABANDONED);
+			signal?.addEventListener("abort", leaveOnAbort, { once: true });
+			if (signal?.aborted) leaveOnAbort();
+			const stopWatching = () => {
 				clearTimeout(admissionTimer);
+				signal?.removeEventListener("abort", leaveOnAbort);
+			};
+			result.then((value) => {
+				stopWatching();
 				resolve(value);
 			}, (error) => {
-				clearTimeout(admissionTimer);
+				stopWatching();
 				reject(error);
 			});
 		});
@@ -59,7 +116,131 @@ function createKeyedSerialQueue() {
 	}
 	return { run };
 }
-var createSpawnGate = createSerialQueue;
+function toMegabytes(bytes) {
+	return Math.round(bytes / BYTES_PER_MEGABYTE);
+}
+function createMemoryAdmission({ readHeadroom, reserveBytesFor, nowMs = Date.now, sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+}), warn = (message) => console.warn(message) }) {
+	let reservations = [];
+	let isInProbeFailureStreak = false;
+	let heldStartCount = 0;
+	let latestHeadroomBytes = null;
+	let latestHeadroomReadAtMs = null;
+	function noteReading(reading, readAtMs) {
+		latestHeadroomReadAtMs = readAtMs;
+		latestHeadroomBytes = reading.ok ? reading.headroomBytes : null;
+		if (reading.ok) {
+			isInProbeFailureStreak = false;
+			return;
+		}
+		if (isInProbeFailureStreak) return;
+		isInProbeFailureStreak = true;
+		warn(`[memory] could not read memory headroom, so starts go ahead unchecked: ${reading.reason}`);
+	}
+	async function admitOrDescribeShortfall(kind, { isDryRun = false } = {}) {
+		const reserveBytes = reserveBytesFor(kind);
+		if (reserveBytes <= 0) return null;
+		const reading = await readHeadroom();
+		const admittedAtMs = nowMs();
+		reservations = liveReservations(reservations, admittedAtMs);
+		noteReading(reading, admittedAtMs);
+		if (!(isDryRun && reading.ok && heldStartCount > 0) && shouldAdmitStart({
+			reading,
+			reserveBytes,
+			reservations,
+			nowMs: admittedAtMs
+		})) {
+			if (!isDryRun) reservations.push({
+				bytes: reserveBytes,
+				admittedAtMs
+			});
+			return null;
+		}
+		const heldBytes = reservations.reduce((total, reservation) => total + reservation.bytes, 0);
+		return {
+			headroomBytes: reading.ok ? reading.headroomBytes : 0,
+			heldBytes,
+			reserveBytes,
+			waitingStartCount: heldStartCount
+		};
+	}
+	async function recheckUntilAdmitted(kind, isStillWanted) {
+		do {
+			await sleep(MEMORY_RECHECK_MS);
+			if (!isStillWanted()) return false;
+		} while (await admitOrDescribeShortfall(kind) !== null);
+		return true;
+	}
+	async function waitForHeadroom(kind, { isStillWanted = () => true, onMemoryWait = () => {} } = {}) {
+		if (!isStillWanted()) return;
+		const shortfall = await admitOrDescribeShortfall(kind);
+		if (shortfall === null) return;
+		if (!isStillWanted()) return;
+		const waitStartedAtMs = nowMs();
+		warn(`[memory] holding a ${kind} start: ${toMegabytes(shortfall.headroomBytes)} MB headroom, ${toMegabytes(shortfall.heldBytes)} MB held for recent starts, ${toMegabytes(shortfall.reserveBytes)} MB reserve needed`);
+		onMemoryWait(true);
+		if (!await recheckUntilAdmitted(kind, isStillWanted).finally(() => onMemoryWait(false))) return;
+		warn(`[memory] admitted a ${kind} start after waiting ${Math.round((nowMs() - waitStartedAtMs) / 1e3)} s`);
+	}
+	return {
+		waitForHeadroom,
+		noteStartHeld: (isHeld) => {
+			heldStartCount += isHeld ? 1 : -1;
+		},
+		gateStatus: () => ({
+			headroomBytes: latestHeadroomBytes,
+			headroomReadAtMs: latestHeadroomReadAtMs,
+			heldStartCount
+		}),
+		describeShortfallNow: (kind) => admitOrDescribeShortfall(kind, { isDryRun: true })
+	};
+}
+function createSpawnGate({ memoryAdmission = null, kind = "session" } = {}) {
+	const queue = createSerialQueue();
+	if (!memoryAdmission) return queue;
+	const admission = memoryAdmission;
+	const queuedStarts = /* @__PURE__ */ new Set();
+	const flaggedStarts = /* @__PURE__ */ new Set();
+	let isHeadStartHeld = false;
+	function flagWaitingForMemory(queuedStart) {
+		if (flaggedStarts.has(queuedStart) || !queuedStart.isStillWanted()) return;
+		flaggedStarts.add(queuedStart);
+		admission.noteStartHeld(true);
+		queuedStart.onMemoryWait(true);
+	}
+	function leaveQueue(queuedStart) {
+		queuedStarts.delete(queuedStart);
+		if (!flaggedStarts.delete(queuedStart)) return;
+		admission.noteStartHeld(false);
+		queuedStart.onMemoryWait(false);
+	}
+	function noteHeadStartHeld(isHeld) {
+		isHeadStartHeld = isHeld;
+		if (!isHeld) return;
+		for (const queuedStart of queuedStarts) flagWaitingForMemory(queuedStart);
+	}
+	function run(fn, options = {}) {
+		const { isStillWanted = () => true, onMemoryWait = () => {} } = options;
+		const queuedStart = {
+			isStillWanted,
+			onMemoryWait
+		};
+		queuedStarts.add(queuedStart);
+		if (isHeadStartHeld) flagWaitingForMemory(queuedStart);
+		const release = () => leaveQueue(queuedStart);
+		const result = queue.run(() => admission.waitForHeadroom(kind, {
+			isStillWanted,
+			onMemoryWait: noteHeadStartHeld
+		}).finally(release).then(fn), options);
+		result.then(release, release);
+		return result;
+	}
+	return {
+		run,
+		idle: queue.idle
+	};
+}
 //#endregion
 //#region server/json-file.ts
 function tmpPathFor(filePath) {
@@ -349,4 +530,4 @@ function createJsonStateStore({ name, filePath, fsPromises = fs.promises, parse,
 	};
 }
 //#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 };
+export { headroomFromReadings as C, parseMemAvailableBytes as D, parseCgroupV2Path as E, cgroupLimitBytes as S, parseCgroupBytes as T, createSpawnGate as _, jsonStateLoadError as a, DEFAULT_CHECK_MEMORY_RESERVE_MB as b, loadedJsonValue as c, writeJsonAtomicSync as d, writeTextAtomic as f, createSerialQueue as g, createMemoryAdmission 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, isQueueAdmissionAbandoned as v, memoryReserveBytes as w, cgroupAncestorPaths as x, isQueueAdmissionTimeout as y };

package/dist/chunks/{knowledge-graph-cli-DApeMzA8.js → knowledge-graph-cli-DcspNqhz.js}

@@ -2,7 +2,7 @@ import { r as errorMessage } from "./text-DoirglWV.js";
 import { s as resolvePackageBin } from "./runtime-paths-BkeftE60.js";
 import { r as execFileSync } from "./child-process-safe-CbQnyh7D.js";
 import { n as glimmervoidHomeDir, t as decideConfigPath } from "./config-path-core-DFt-TemS.js";
-import { r as BrowserConfig } from "./config-BYc2z1Oc.js";
+import { r as BrowserConfig } from "./config-BHBZsCBc.js";
 import fs, { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import path, { dirname, join, posix, resolve, win32 } from "node:path";
 import os from "node:os";

package/dist/chunks/{loopback-post-DJ6iYWuL.js → loopback-post-DZK7YibD.js}

@@ -1,8 +1,8 @@
 import { a as isLoopbackHostname } from "./hook-relay-core-DA_bz2KA.js";
 import { n as decideGuardrailsProxy } from "./guardrails-proxy-core-BI3rdY-m.js";
-import http from "node:http";
 //#region session/loopback-post.ts
 var POST_TIMEOUT_MS = 1500;
+var http = process.getBuiltinModule("node:http");
 function refusal(reason) {
 	return {
 		reason,