@ekrooh/bare 0.4.0 → 0.5.0

package/dist/runtime.mjs

@@ -1,12 +1,13 @@
-import { MessageProtocol, MessageType, createPluginRegistry, createPluginRouter } from "./index.mjs";
-import { t as createDefaultPlugins } from "./plugins-1KweEBct.mjs";
+import { c as createRequestId, d as createPluginRouter, g as ErrorCode, o as MessageProtocol, u as createPluginRegistry, v as MAX_HEADER_BYTES, y as MessageType } from "./messages-BbpF3wNH.mjs";
+import { t as createDefaultPlugins } from "./plugins-DZu_NWVp.mjs";
+import { t as createLogRingBuffer } from "./store-DTg1jN5E.mjs";
 import { TextDecoder, TextEncoder } from "bare-encoding";
 import fs from "bare-fs";
 import path from "bare-path";
+import crypto from "bare-crypto";
 import http from "bare-http1";
 import ws from "bare-ws";
-import crypto from "bare-crypto";
-//#region core/lib/get-ipc.ts
+// core/lib/get-ipc.ts
 /**
 * Returns the active IPC channel.
 * In BareKit (Android), it uses BareKit.IPC.
@@ -17,30 +18,230 @@ function getIPC() {
 	if (IPC && typeof IPC.resume === "function") IPC.resume();
 	return IPC;
 }
-//#endregion
-//#region core/messages/host-ipc.ts
+// core/messages/encode-response.ts
+/** Encodes a routed response. A response that cannot be encoded (a result over
+* the 64 KB header limit, or one that does not serialize) is replaced by an
+* error response for the same request, so the caller fails fast instead of
+* waiting for a timeout that never explains why. */
+function encodeResponse(protocol, response) {
+	try {
+		return protocol.encode(MessageType.ENVELOPE, response, null);
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		const tooLarge = /too large/i.test(reason);
+		console.error(`Response for ${response.pluginId}.${response.event} dropped: ${reason}`);
+		return protocol.encode(MessageType.ENVELOPE, {
+			type: "INVOKE_RESPONSE",
+			pluginId: response.pluginId,
+			event: response.event,
+			requestId: response.requestId,
+			error: {
+				code: tooLarge ? ErrorCode.FRAME_TOO_LARGE : ErrorCode.INVALID_RESPONSE,
+				message: `Response for ${response.pluginId}.${response.event} could not be sent: ${reason}`
+			}
+		}, null);
+	}
+}
+// core/messages/framing.ts
+/** Smallest buffer allocated for a partial frame whose length is not yet known
+* (fewer than 7 prefix bytes have arrived). */
+const MIN_PARTIAL_BYTES = 64;
+/** A partial-frame buffer larger than this is released once drained, so one
+* large frame does not pin its memory for the rest of the session. */
+const RETAIN_BYTES = 65536;
+function createFrameDecoder(protocol) {
+	/** Partial-frame storage: the first `length` bytes are buffered data. Empty
+	* whenever nothing is buffered, so a chunk of whole frames is decoded
+	* straight from the caller's bytes without being copied in first. */
+	let buffer = /* @__PURE__ */ new Uint8Array(0);
+	let length = 0;
+	let error = null;
+	function fail(err) {
+		error = err;
+		buffer = /* @__PURE__ */ new Uint8Array(0);
+		length = 0;
+	}
+	/** Grows `buffer` to hold at least `bytes`, preserving buffered data. */
+	function reserve(bytes) {
+		if (buffer.byteLength >= bytes) return;
+		const next = new Uint8Array(Math.max(bytes, MIN_PARTIAL_BYTES));
+		next.set(buffer.subarray(0, length), 0);
+		buffer = next;
+	}
+	/** Keeps `rest` (the unconsumed tail of `source`) as the buffered partial,
+	* sized for `frameLen` when the incomplete frame's length is known. */
+	function retain(source, from, to, frameLen) {
+		const rest = to - from;
+		if (rest === 0) {
+			length = 0;
+			if (buffer.byteLength > RETAIN_BYTES) buffer = /* @__PURE__ */ new Uint8Array(0);
+			return;
+		}
+		if (source === buffer) {
+			buffer.copyWithin(0, from, to);
+			length = rest;
+			reserve(frameLen);
+			return;
+		}
+		length = 0;
+		reserve(Math.max(rest, frameLen));
+		buffer.set(source.subarray(from, to), 0);
+		length = rest;
+	}
+	function push(chunk) {
+		if (error) return [];
+		let source;
+		let end;
+		if (length === 0) {
+			source = chunk;
+			end = chunk.byteLength;
+		} else {
+			reserve(length + chunk.byteLength);
+			buffer.set(chunk, length);
+			length += chunk.byteLength;
+			source = buffer;
+			end = length;
+		}
+		const out = [];
+		let offset = 0;
+		let pendingFrameLen = 0;
+		while (end - offset >= 7) {
+			const headerLen = source[offset + 2] << 8 | source[offset + 3];
+			if (headerLen > 65535) {
+				fail(/* @__PURE__ */ new Error(`Header too large: ${headerLen} bytes, maximum is ${MAX_HEADER_BYTES}`));
+				return out;
+			}
+			const payloadLen = source[offset + 4] << 16 | source[offset + 5] << 8 | source[offset + 6];
+			const frameLen = 7 + headerLen + payloadLen;
+			if (frameLen > protocol.maxFrameBytes) {
+				fail(/* @__PURE__ */ new Error(`Frame too large: ${frameLen} bytes, maximum is ${protocol.maxFrameBytes}`));
+				return out;
+			}
+			if (end - offset < frameLen) {
+				pendingFrameLen = frameLen;
+				break;
+			}
+			const frame = Uint8Array.prototype.slice.call(source, offset, offset + frameLen);
+			offset += frameLen;
+			try {
+				out.push(protocol.decode(frame));
+			} catch (err) {
+				fail(err instanceof Error ? err : new Error(String(err)));
+				return out;
+			}
+		}
+		retain(source, offset, end, pendingFrameLen);
+		if (length > protocol.maxFrameBytes) fail(/* @__PURE__ */ new Error(`Frame buffer exceeded ${protocol.maxFrameBytes} bytes with no complete frame`));
+		return out;
+	}
+	return {
+		push,
+		clear() {
+			buffer = /* @__PURE__ */ new Uint8Array(0);
+			length = 0;
+			error = null;
+		},
+		get error() {
+			return error;
+		}
+	};
+}
+// core/messages/channel-health.ts
+/**
+* Per-channel decode/framing health tracker for the host↔worklet IPC pipe.
+*
+* The IPC pipe is a raw byte stream with no reconnect seam. A single corrupted
+* byte permanently desyncs the frame boundaries, so every subsequent frame
+* fails to decode. Unconditionally clearing the decoder after each failure
+* keeps parsing garbage forever — the channel is silently dead for the rest of
+* the session, and all host-delegated invokes time out until a restart.
+*
+* Instead we count consecutive decode/framing failures and treat a sustained run
+* as a fatal, unrecoverable desync. The caller then stops parsing rather than
+* spinning on garbage. A single isolated bad chunk is tolerated (the counter
+* resets on any successful frame batch), so transient corruption does not kill a
+* healthy channel.
+*/
+var ChannelHealth = class {
+	maxConsecutiveFailures;
+	consecutiveFailures = 0;
+	fatal = false;
+	constructor(maxConsecutiveFailures = 5) {
+		this.maxConsecutiveFailures = maxConsecutiveFailures;
+	}
+	/** Record a successful frame batch; resets the consecutive-failure counter. */
+	noteSuccess() {
+		this.consecutiveFailures = 0;
+	}
+	/**
+	* Record a decode/framing failure. Returns `true` once the run of
+	* consecutive failures reaches {@link maxConsecutiveFailures}, signalling the
+	* caller that the channel is fatally desynced and parsing should stop.
+	*/
+	noteFailure() {
+		this.consecutiveFailures++;
+		if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
+			this.fatal = true;
+			return true;
+		}
+		return false;
+	}
+	/** Whether a fatal, unrecoverable desync has been reached. */
+	get isFatal() {
+		return this.fatal;
+	}
+	/** Number of consecutive failures since the last successful frame batch. */
+	get failures() {
+		return this.consecutiveFailures;
+	}
+};
+// core/messages/host-ipc.ts
 function toUint8Array$2(data) {
 	if (data instanceof Uint8Array) return data;
 	if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) return new Uint8Array(data);
 	return new Uint8Array(data);
 }
-function newCorrelationId() {
-	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
+/** Hard ceiling on concurrently pending host calls. Above this, the oldest call
+* is dropped (its timer cleared and promise rejected) so a flood of invokes
+* cannot grow the pending map without bound. */
+const MAX_CONCURRENT_HOST_CALLS = 1024;
+/** Sane default for a host invoke: five-minute waits let a single stalled host
+* call pin a slot indefinitely, so we default to 30s instead. */
+const DEFAULT_HOST_INVOKE_TIMEOUT_MS = 3e4;
 function writeEncoded(ipc, bytes) {
-	if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") ipc.write(Buffer.from(bytes));
+	if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") ipc.write(Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes));
 	else ipc.write(bytes);
 }
 function createHostIpcBridge(config) {
 	const { ipc, protocol } = config;
 	const pending = /* @__PURE__ */ new Map();
+	function track(requestId, slot) {
+		if (pending.size >= MAX_CONCURRENT_HOST_CALLS) {
+			const oldest = pending.keys().next().value;
+			if (oldest !== void 0) {
+				const dropped = pending.get(oldest);
+				if (dropped) {
+					clearTimeout(dropped.timer);
+					dropped.reject(/* @__PURE__ */ new Error(`host invoke dropped: too many concurrent host calls (${oldest})`));
+				}
+				pending.delete(oldest);
+			}
+		}
+		const existing = pending.get(requestId);
+		if (existing) {
+			clearTimeout(existing.timer);
+			existing.reject(/* @__PURE__ */ new Error(`host invoke superseded by a new call (${requestId})`));
+			pending.delete(requestId);
+		}
+		pending.set(requestId, slot);
+	}
 	function waitFor(requestId, expectedType, timeoutMs) {
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
 				pending.delete(requestId);
 				reject(/* @__PURE__ */ new Error(`Host IPC timeout waiting for ${String(expectedType)} (${requestId})`));
 			}, timeoutMs);
-			pending.set(requestId, {
+			track(requestId, {
 				timer,
 				resolve: (h) => {
 					clearTimeout(timer);
@@ -50,31 +251,42 @@ function createHostIpcBridge(config) {
 						return;
 					}
 					reject(/* @__PURE__ */ new Error(`Unexpected host response type ${h.type}, expected ${String(expectedType)}`));
-				}
+				},
+				reject
 			});
 		});
 	}
+	/** Classifies a pre-decoded downstream message: resolves the matching pending
+	* host call when it is a `HOST_CAPABILITIES_RESPONSE` or `HOST_INVOKE_RESPONSE`
+	* for a known `requestId`; otherwise returns false so the caller can route the
+	* message through the plugin router (host responses never reach plugins). */
+	function consumeDownstream(parsed) {
+		const h = parsed.header;
+		if (h.type !== "HOST_CAPABILITIES_RESPONSE" && h.type !== "HOST_INVOKE_RESPONSE") return false;
+		const id = h.requestId;
+		if (!id) return false;
+		const slot = pending.get(id);
+		if (!slot) return false;
+		clearTimeout(slot.timer);
+		pending.delete(id);
+		slot.resolve(h);
+		return true;
+	}
 	return {
+		tryConsumeDownstream: consumeDownstream,
 		tryConsumeDownstreamFromHost(raw) {
 			let msg;
 			try {
 				msg = protocol.decode(toUint8Array$2(raw));
-			} catch {
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				console.debug(`[ipc] dropped undecodable host frame: ${message}`);
 				return false;
 			}
-			const h = msg.header;
-			if (h.type !== "HOST_CAPABILITIES_RESPONSE" && h.type !== "HOST_INVOKE_RESPONSE") return false;
-			const id = h.requestId;
-			if (!id) return false;
-			const slot = pending.get(id);
-			if (!slot) return false;
-			clearTimeout(slot.timer);
-			pending.delete(id);
-			slot.resolve(h);
-			return true;
+			return consumeDownstream(msg);
 		},
 		async queryCapabilities(timeoutMs = 5e3) {
-			const requestId = newCorrelationId();
+			const requestId = createRequestId();
 			const promise = waitFor(requestId, "HOST_CAPABILITIES_RESPONSE", timeoutMs);
 			const header = {
 				type: "HOST_CAPABILITIES_QUERY",
@@ -83,7 +295,7 @@ function createHostIpcBridge(config) {
 			writeEncoded(ipc, protocol.encode(MessageType.ENVELOPE, header, null));
 			return (await promise).capabilities ?? [];
 		},
-		async invokeOnHost(header, payload, timeoutMs = 3e5) {
+		async invokeOnHost(header, payload, timeoutMs = DEFAULT_HOST_INVOKE_TIMEOUT_MS) {
 			const requestId = header.requestId;
 			if (!requestId) return null;
 			const promise = waitFor(requestId, "HOST_INVOKE_RESPONSE", timeoutMs);
@@ -107,8 +319,171 @@ function createHostIpcBridge(config) {
 		}
 	};
 }
-//#endregion
-//#region core/server/static-file-server.ts
+// core/logs/capture.ts
+const LEVEL_RANK = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+function safeStringify(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Error) return value.stack ?? value.message;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+function formatArgs(args) {
+	if (args.length === 0) return "";
+	return args.map((a) => safeStringify(a)).join(" ");
+}
+/**
+* Installs console interception at startup: binds the original console methods,
+* forwards to them (so dev stdout and e2e console assertions stay intact), and
+* feeds a {@link LogStore}. Every step is try/catch-wrapped so a failure in the
+* seam can never break boot or swallow the consumer's own log call.
+*/
+function installConsoleCapture(store, source = "backend", options = {}) {
+	const minRank = LEVEL_RANK[options.minLevel ?? "debug"];
+	const original = {
+		debug: console.debug,
+		log: console.log,
+		info: console.info,
+		warn: console.warn,
+		error: console.error
+	};
+	const wrap = (method, level) => {
+		const recorded = LEVEL_RANK[level] >= minRank;
+		return (...args) => {
+			if (recorded) try {
+				store.append({
+					ts: Date.now(),
+					level,
+					source,
+					message: formatArgs(args)
+				});
+			} catch {}
+			try {
+				original[method].apply(console, args);
+			} catch {}
+		};
+	};
+	console.debug = wrap("debug", "debug");
+	console.log = wrap("log", "info");
+	console.info = wrap("info", "info");
+	console.warn = wrap("warn", "warn");
+	console.error = wrap("error", "error");
+	return {
+		source,
+		store,
+		restore() {
+			console.debug = original.debug;
+			console.log = original.log;
+			console.info = original.info;
+			console.warn = original.warn;
+			console.error = original.error;
+		}
+	};
+}
+// core/messages/backpressure.ts
+/** Honours `write() === false`: once the target signals pressure, frames queue
+* (bounded) until it drains instead of piling up inside the stream. */
+function createBoundedWriter(target, options) {
+	const hardMax = options.hardMaxQueuedBytes ?? options.maxQueuedBytes * 8;
+	let queue = [];
+	let head = 0;
+	let queued = 0;
+	let blocked = false;
+	let dead = false;
+	let dropped = 0;
+	function flush() {
+		while (!blocked && head < queue.length) {
+			const next = queue[head++];
+			queued -= next.byteLength;
+			if (!target.write(next)) blocked = true;
+		}
+		if (head === queue.length) {
+			queue = [];
+			head = 0;
+		} else if (head > 1024) {
+			queue = queue.slice(head);
+			head = 0;
+		}
+		if (!blocked && dropped > 0) {
+			console.warn(`[loopback] dropped ${dropped} push frame(s) while the client was not reading`);
+			dropped = 0;
+		}
+	}
+	target.on("drain", () => {
+		blocked = false;
+		flush();
+	});
+	return {
+		write(frame, writeOptions) {
+			if (dead) return false;
+			if (!blocked && head === queue.length) {
+				if (!target.write(frame)) blocked = true;
+				return true;
+			}
+			const size = frame.byteLength;
+			if (writeOptions?.droppable) {
+				if (queued + size > options.maxQueuedBytes) {
+					if (dropped === 0) console.warn("[loopback] client is not reading; dropping push frames (newest first)");
+					dropped++;
+					return false;
+				}
+			} else if (queued > 0 && queued + size > hardMax) {
+				dead = true;
+				queue = [];
+				head = 0;
+				queued = 0;
+				options.onOverflow();
+				return false;
+			}
+			queue.push(frame);
+			queued += size;
+			return true;
+		},
+		clear() {
+			queue = [];
+			head = 0;
+			queued = 0;
+		},
+		get queuedBytes() {
+			return queued;
+		}
+	};
+}
+/** Pauses an inbound stream while too much routed work is pending, so a fast
+* sender cannot queue work faster than it completes. */
+function createInboundGate(options) {
+	let pending = 0;
+	let paused = false;
+	function done() {
+		pending--;
+		if (paused && pending <= options.low) {
+			paused = false;
+			options.resume();
+		}
+	}
+	return {
+		/** Counts `work` as pending until it settles. */
+		track(work) {
+			pending++;
+			if (!paused && pending >= options.high) {
+				paused = true;
+				options.pause();
+			}
+			work.then(done, done);
+		},
+		get pending() {
+			return pending;
+		}
+	};
+}
+// core/server/static-file-server.ts
 const MIME_BY_EXTENSION = {
 	html: "text/html",
 	js: "text/javascript",
@@ -133,17 +508,31 @@ function mimeTypeFor(filePath) {
 	const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
 	return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
 }
-/** Extracts the `token` query param from a raw query string (`a=1&token=x`). */
-function tokenFromQuery(query) {
-	for (const pair of query.split("&")) {
-		const eq = pair.indexOf("=");
-		if (eq === -1) continue;
-		if (pair.slice(0, eq) === "token") return pair.slice(eq + 1);
-	}
-	return null;
+/** Files under `assets/` whose name ends in an 8-character content hash before
+* the extension (the Vite/Rolldown default, e.g. `assets/main-DkY3x9qZ.js`)
+* are treated as content-addressed. Anything else — including `index.html` —
+* must be revalidated. */
+const HASHED_ASSET = /^assets\/[^/]+-[A-Za-z0-9_-]{8}\.[A-Za-z0-9]+$/;
+function cachePolicyFor(rel, mountIsPublic) {
+	if (!mountIsPublic) return "no-store";
+	return HASHED_ASSET.test(rel) ? "immutable" : "revalidate";
+}
+/** Weak validator from size and mtime. Weak because the same bytes can be
+* re-written with a new mtime, which only costs one extra full response. */
+function etagFor(stat) {
+	return `W/"${stat.size.toString(16)}-${Math.floor(stat.mtimeMs).toString(16)}"`;
+}
+/** Whether an `If-None-Match` header (a list of validators, or `*`) matches. */
+function etagMatches(header, etag) {
+	if (typeof header !== "string") return false;
+	return header.split(",").some((candidate) => candidate.trim() === etag || candidate.trim() === "*");
 }
 /** Reads the token from the `X-Bare-Token` request header (parser-lowercased).
-* `fetch`-based non-browser clients that cannot carry cookies use this. */
+* `fetch`-based non-browser clients that cannot carry cookies use this.
+* Security note: like the `bare_session` cookie, this credential travels the
+* cleartext 127.0.0.1 loopback — it is only trusted from the bound origin
+* (enforced by `originAllowed`), and is an escape hatch for same-loopback
+* non-browser clients; it is accepted over TLS-agnostic plain HTTP by design. */
 function tokenFromHeaders(headers) {
 	const value = headers["x-bare-token"];
 	return typeof value === "string" ? value : null;
@@ -164,6 +553,14 @@ function cookieSession(headers) {
 function sessionNonce(token) {
 	return crypto.createHash("blake2b-256").update(token).digest("hex");
 }
+/** Constant-time string comparison. bare-crypto's `timingSafeEqual` requires
+* equal-length inputs (it throws otherwise), so guard on byte length first. */
+function secretEquals(a, b) {
+	const ab = Buffer.from(a);
+	const bb = Buffer.from(b);
+	if (ab.length !== bb.length) return false;
+	return crypto.timingSafeEqual(ab, bb);
+}
 /** Parses a `Range: bytes=<start>-<end>` header. Returns `null` when absent or
 * unsatisfiable (caller falls back to a 200 full response). */
 function parseRange(value, size) {
@@ -190,47 +587,112 @@ function parseRange(value, size) {
 * Buffers, bare-http1 emits Uint8Arrays, and a setEncoding'd stream emits
 * strings — `String(uint8array)` would join bytes with commas, so decode
 * explicitly (the `/login` token body must match byte-for-byte). */
-function collectRequestBody(req) {
-	return new Promise((resolve) => {
+function collectRequestBody(req, maxBytes = Infinity) {
+	return new Promise((resolve, reject) => {
 		const decoder = new TextDecoder();
 		let body = "";
+		let byteCount = 0;
+		let exceeded = false;
 		req.on("data", (chunk) => {
-			body += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+			if (exceeded) return;
+			const str = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+			body += str;
+			byteCount += typeof chunk === "string" ? new TextEncoder().encode(chunk).byteLength : chunk.byteLength;
+			if (byteCount > maxBytes) {
+				exceeded = true;
+				reject(/* @__PURE__ */ new Error("Request body too large"));
+			}
+		});
+		req.on("end", () => {
+			if (exceeded) return;
+			const final = body + decoder.decode(/* @__PURE__ */ new Uint8Array(0));
+			if (byteCount > maxBytes) {
+				reject(/* @__PURE__ */ new Error("Request body too large"));
+				return;
+			}
+			resolve(final);
 		});
-		req.on("end", () => resolve(body + decoder.decode(/* @__PURE__ */ new Uint8Array(0))));
 	});
 }
 /**
 * The single loopback HTTP+WS server for the worklet. One origin serves the
 * web app (`/`), the media files mounted by plugins, and the framed-protocol
 * WebSocket socket the page connects to. On device it binds `127.0.0.1` on an
-* ephemeral port. The bundled web app (directory mounts) is public content — a
-* fresh WebView must load the page before the page can `POST /login`. Mounted
-* session files (media) and the WS upgrade are gated by a per-session token,
-* accepted as a `bare_session` cookie (set via `POST /login`), the
-* `X-Bare-Token` header, or a `?token=` query param — defense in depth for
-* non-browser clients. All responses send `Referrer-Policy: no-referrer` so
-* token-bearing URLs never leak through a Referer header.
+* ephemeral port. Only the explicit **bootstrap** directory mount (`/`, marked
+* `{ public: true }`) is world-readable before auth — a fresh WebView must load
+* the page before it can `POST /login`. Mounted session files (media) and the
+* WS upgrade are gated by a per-session token, accepted as a `bare_session`
+* cookie (set via `POST /login` with the one-time bootstrap nonce or the token)
+* or the `X-Bare-Token` header (non-browser clients). The URL `?token=` query
+* param is **not** accepted — a token must never appear in a URL an observer
+* could read. All responses send `Referrer-Policy: no-referrer`.
 */
 function createLoopbackServer(options = {}) {
 	const host = options.host ?? "127.0.0.1";
 	const port = options.port ?? 0;
 	const authEnabled = options.auth ?? true;
 	const wsIdleTimeoutMs = options.wsIdleTimeoutMs ?? 6e4;
+	const wsDeadPeerTimeoutMs = options.wsDeadPeerTimeoutMs ?? 1e4;
+	const wsReplaceMinIntervalMs = options.wsReplaceMinIntervalMs ?? 1e3;
+	const wsMaxQueuedBytes = options.wsMaxQueuedBytes ?? 2097152;
+	/** URL-safe random secret for the session token / bootstrap nonce. */
+	const randomSecret = () => crypto.randomBytes(32).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 	const fileMounts = /* @__PURE__ */ new Map();
 	const dirMounts = /* @__PURE__ */ new Map();
+	const publicDirMounts = /* @__PURE__ */ new Set();
 	const routeHandlers = /* @__PURE__ */ new Map();
 	const connectionHandlers = [];
 	let token = options.token ?? null;
+	let bootstrapNonce = null;
+	/** The most recently spent bootstrap nonce, kept only to answer replays of
+	* it with 409 (valid-once-but-consumed) instead of 401 (bad credential). */
+	let spentBootstrapNonce = null;
 	let boundOrigin = "";
 	let originPromise = null;
 	let activeSocket = null;
-	function isAuthorized(headers, query) {
+	let activeWriter = null;
+	let activeSince = 0;
+	/** Non-fatal, never-throwing debug for skipped work (a missing file, a failed
+	* write) — observable in the `core.logs` ring buffer, never able to alter
+	* control flow. */
+	function debugSkip(message) {
+		try {
+			console.debug(message);
+		} catch {}
+	}
+	/** The session cookie value derived from `token`, hashed once per token
+	* instead of on every request (the token is fixed after bind). */
+	let nonceToken = null;
+	let nonceValue = "";
+	function sessionCookieValue(forToken) {
+		if (nonceToken !== forToken) {
+			nonceValue = sessionNonce(forToken);
+			nonceToken = forToken;
+		}
+		return nonceValue;
+	}
+	function isAuthorized(headers) {
 		if (!authEnabled) return true;
 		if (token === null) return false;
-		if (tokenFromQuery(query) === token) return true;
-		if (tokenFromHeaders(headers) === token) return true;
-		return cookieSession(headers) === sessionNonce(token);
+		if (secretEquals(tokenFromHeaders(headers) ?? "", token)) return true;
+		return secretEquals(cookieSession(headers) ?? "", sessionCookieValue(token));
+	}
+	/** DNS-rebinding and cross-origin defense for plain HTTP. In auth (device)
+	* mode the server never advertises a stable hostname, so a browser request
+	* must either carry a same-origin `Origin` header (fetches/subresources) or,
+	* for top-level navigations that send no Origin (the initial WebView load),
+	* a `Host` header pointing back at the bound 127.0.0.1:port. A DNS-rebinding
+	* navigation resolves the loopback address under an attacker-controlled
+	* hostname and therefore sends a foreign `Host`. Dev (auth off) is open. */
+	function originAllowed(headers) {
+		if (!authEnabled) return true;
+		if (boundOrigin === "") return true;
+		const boundHostPort = boundOrigin.slice(7);
+		const host = headers["host"];
+		if (typeof host !== "string" || host !== boundHostPort) return false;
+		const origin = headers["origin"];
+		if (typeof origin === "string" && origin.length > 0 && origin !== boundOrigin) return false;
+		return true;
 	}
 	function writeError(res, status, message) {
 		res.writeHead(status, {
@@ -240,20 +702,30 @@ function createLoopbackServer(options = {}) {
 		res.end(message);
 	}
 	function handleLogin(req, res) {
-		collectRequestBody(req).then((body) => {
-			if (!(!authEnabled || token !== null && body.trim() === token)) {
-				writeError(res, 401, "Unauthorized");
+		collectRequestBody(req, 4096).then((body) => {
+			const trimmed = body.trim();
+			const byToken = token !== null && secretEquals(trimmed, token);
+			const byBootstrap = bootstrapNonce !== null && secretEquals(trimmed, bootstrapNonce);
+			const bySession = authEnabled && isAuthorized(req.headers);
+			const accepted = !authEnabled || byToken || byBootstrap || bySession;
+			const bySpentBootstrap = bootstrapNonce === null && spentBootstrapNonce !== null && secretEquals(trimmed, spentBootstrapNonce);
+			if (!accepted) {
+				writeError(res, bySpentBootstrap ? 409 : 401, "Unauthorized");
 				return;
 			}
+			if (byBootstrap && bootstrapNonce !== null) {
+				spentBootstrapNonce = bootstrapNonce;
+				bootstrapNonce = null;
+			}
 			const headers = {
 				"Content-Type": "text/plain",
 				"Cache-Control": "no-store",
 				"Referrer-Policy": "no-referrer"
 			};
-			if (authEnabled && token !== null) headers["Set-Cookie"] = `bare_session=${sessionNonce(token)}; HttpOnly; SameSite=Lax; Path=/`;
+			if (authEnabled && token !== null) headers["Set-Cookie"] = `bare_session=${sessionCookieValue(token)}; HttpOnly; SameSite=Lax; Path=/`;
 			res.writeHead(200, headers);
 			res.end("ok");
-		});
+		}).catch(() => writeError(res, 413, "Request Entity Too Large"));
 	}
 	/** Resolves a request path to a file mount, or a directory mount + relative
 	* path. Directory mounts win on longest-prefix match. */
@@ -274,26 +746,33 @@ function createLoopbackServer(options = {}) {
 			if (prefix.length > bestPrefix) {
 				best = {
 					dirPath,
-					rel
+					rel,
+					public: publicDirMounts.has(prefix)
 				};
 				bestPrefix = prefix.length;
 			}
 		}
 		return best ? {
-			kind: "dir",
-			dirPath: best.dirPath,
-			rel: best.rel
+			...best,
+			kind: "dir"
 		} : null;
 	}
-	/** Resolves a directory-mount request to a concrete file, applying the SPA
-	* fallback (unknown GET navigation → `index.html`). Subresource requests
+	/** Resolves a directory-mount request to a concrete file. Only a `public`
+	* (bootstrap) mount applies the SPA fallback (unknown navigation GET →
+	* `index.html`); a non-public directory mount 404s unknown paths so
+	* unauthenticated clients never receive bootstrap HTML. Subresource requests
 	* (`Accept` without `text/html`) never fall back — a missing asset is a 404. */
 	function resolveDirFile(mount, headers) {
 		const candidate = mount.rel === "" ? mount.dirPath : path.join(mount.dirPath, mount.rel);
 		try {
-			if (fs.statSync(candidate).isFile()) return candidate;
+			const stat = fs.statSync(candidate);
+			if (stat.isFile()) return {
+				filePath: candidate,
+				stat
+			};
 		} catch {}
 		if (mount.rel === "") return indexHtmlIfPresent(mount.dirPath);
+		if (!mount.public) return null;
 		const accept = headers["accept"];
 		if (typeof accept !== "string" || !accept.includes("text/html")) return null;
 		return indexHtmlIfPresent(mount.dirPath);
@@ -301,15 +780,29 @@ function createLoopbackServer(options = {}) {
 	function indexHtmlIfPresent(dirPath) {
 		try {
 			const index = path.join(dirPath, "index.html");
-			if (fs.statSync(index).isFile()) return index;
-		} catch {}
+			const stat = fs.statSync(index);
+			if (stat.isFile()) return {
+				filePath: index,
+				stat
+			};
+		} catch {
+			debugSkip(`[static-server] indexHtmlIfPresent: no index.html under ${dirPath} — 404`);
+		}
 		return null;
 	}
-	function serveFile(req, res, filePath) {
+	/** Strict Content-Security-Policy for HTML documents served by the loopback
+	* server; subresources must stay same-origin (the page talks to the worklet
+	* over the loopback socket). `style-src` needs `'unsafe-inline'` for the
+	* bundled web app's inline styles and `connect-src` allows the same-origin
+	* protocol socket. */
+	const CSP_HEADER = "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' ws:";
+	function serveFile(req, res, filePath, knownStat, cache = "no-store") {
 		let stat;
-		try {
+		if (knownStat) stat = knownStat;
+		else try {
 			stat = fs.statSync(filePath);
 		} catch {
+			debugSkip(`[static-server] serveFile: stat failed for ${filePath} — 404`);
 			writeError(res, 404, "Not found");
 			return;
 		}
@@ -317,14 +810,16 @@ function createLoopbackServer(options = {}) {
 			writeError(res, 404, "Not found");
 			return;
 		}
+		const contentType = mimeTypeFor(filePath);
+		const cspHeader = contentType === "text/html" ? { "Content-Security-Policy": CSP_HEADER } : {};
 		const range = parseRange(req.headers["range"], stat.size);
 		if (range) {
 			res.writeHead(206, {
-				"Content-Type": mimeTypeFor(filePath),
+				"Content-Type": contentType,
 				"Content-Range": `bytes ${range.start}-${range.end}/${stat.size}`,
 				"Content-Length": range.end - range.start + 1,
 				"Accept-Ranges": "bytes",
-				"Access-Control-Allow-Origin": "*",
+				...cspHeader,
 				"Referrer-Policy": "no-referrer",
 				"Cache-Control": "no-store"
 			});
@@ -332,13 +827,25 @@ function createLoopbackServer(options = {}) {
 			pipeFile(res, filePath, range);
 			return;
 		}
+		const cacheHeaders = cache === "no-store" ? { "Cache-Control": "no-store" } : {
+			"Cache-Control": cache === "immutable" ? "max-age=31536000, immutable" : "no-cache",
+			ETag: etagFor(stat)
+		};
+		if (cache !== "no-store" && etagMatches(req.headers["if-none-match"], cacheHeaders.ETag)) {
+			res.writeHead(304, {
+				...cacheHeaders,
+				"Referrer-Policy": "no-referrer"
+			});
+			res.end();
+			return;
+		}
 		res.writeHead(200, {
-			"Content-Type": mimeTypeFor(filePath),
+			"Content-Type": contentType,
 			"Content-Length": stat.size,
 			"Accept-Ranges": "bytes",
-			"Access-Control-Allow-Origin": "*",
+			...cspHeader,
 			"Referrer-Policy": "no-referrer",
-			"Cache-Control": "no-store"
+			...cacheHeaders
 		});
 		res.flushHeaders();
 		pipeFile(res, filePath);
@@ -365,9 +872,13 @@ function createLoopbackServer(options = {}) {
 	}
 	const server = http.createServer((req, res) => {
 		try {
-			const [rawPath, query = ""] = (req.url ?? "/").split("?");
+			const [rawPath] = (req.url ?? "/").split("?");
 			const cleanPath = rawPath.split("#")[0].replace(/\/+$/, "") || "/";
 			const headers = req.headers;
+			if (!originAllowed(headers)) {
+				writeError(res, 403, "Forbidden");
+				return;
+			}
 			if (req.method === "POST" && cleanPath === "/login") {
 				handleLogin(req, res);
 				return;
@@ -378,7 +889,7 @@ function createLoopbackServer(options = {}) {
 			}
 			const route = routeHandlers.get(`${req.method} ${cleanPath}`);
 			if (route) {
-				if (!isAuthorized(headers, query)) {
+				if (!isAuthorized(headers)) {
 					writeError(res, 401, "Unauthorized");
 					return;
 				}
@@ -390,16 +901,25 @@ function createLoopbackServer(options = {}) {
 				return;
 			}
 			const mount = resolveMount(cleanPath);
-			if (!(mount !== null && mount.kind === "dir") && !isAuthorized(headers, query)) {
+			if (!(mount !== null && mount.kind === "dir" && mount.public) && !isAuthorized(headers)) {
 				writeError(res, 401, "Unauthorized");
 				return;
 			}
-			const filePath = mount === null ? null : mount.kind === "file" ? mount.filePath : resolveDirFile(mount, headers);
-			if (filePath === null) {
+			if (mount === null) {
 				writeError(res, 404, "Not found");
 				return;
 			}
-			serveFile(req, res, filePath);
+			if (mount.kind === "file") {
+				serveFile(req, res, mount.filePath);
+				return;
+			}
+			const resolved = resolveDirFile(mount, headers);
+			if (resolved === null) {
+				writeError(res, 404, "Not found");
+				return;
+			}
+			const servedRel = resolved.filePath.slice(mount.dirPath.length).replace(/\\/g, "/").replace(/^\/+/, "");
+			serveFile(req, res, resolved.filePath, resolved.stat, cachePolicyFor(servedRel, mount.public));
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
 			res.writeHead(500, { "Content-Type": "text/plain" });
@@ -408,11 +928,12 @@ function createLoopbackServer(options = {}) {
 	});
 	function origin() {
 		if (!originPromise) originPromise = new Promise((resolve, reject) => {
-			token ??= crypto.randomBytes(32).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+			token ??= randomSecret();
+			bootstrapNonce ??= randomSecret();
 			server.on("error", reject);
 			server.listen(port, host, () => {
 				const address = server.address();
-				boundOrigin = `http://${host}:${address.port}`;
+				boundOrigin = `http://${host}:${address?.port}`;
 				resolve(boundOrigin);
 			});
 		});
@@ -420,34 +941,68 @@ function createLoopbackServer(options = {}) {
 	}
 	server.on("upgrade", (req, socket, head) => {
 		const headers = req.headers;
-		const [, query = ""] = (req.url ?? "").split("?");
-		const origin = headers["origin"];
-		if (authEnabled && typeof origin === "string" && origin.length > 0 && boundOrigin !== "" && origin !== boundOrigin) {
+		const reject = (reason) => {
+			console.error(`[loopback] upgrade rejected: ${reason}`);
 			socket.destroy();
+		};
+		const origin = headers["origin"];
+		const allowed = typeof origin === "string" && origin.length > 0 && origin === boundOrigin && boundOrigin !== "";
+		if (authEnabled && !allowed) {
+			reject(`origin mismatch (got ${typeof origin === "string" && origin ? `'${origin}'` : "no Origin header"}, bound '${boundOrigin}')`);
 			return;
 		}
-		if (!isAuthorized(headers, query)) {
-			socket.destroy();
+		if (!isAuthorized(headers)) {
+			reject(`unauthorized (${headers["cookie"] ? "cookie present but invalid" : "no bare_session cookie"})`);
 			return;
 		}
-		if (activeSocket) {
-			socket.destroy();
+		if (activeSocket && Date.now() - activeSince < wsReplaceMinIntervalMs) {
+			reject("replacement rate limit (a protocol socket was just accepted)");
 			return;
 		}
 		ws.Server.handshake(req, socket, head, (err) => {
 			if (err) {
-				socket.destroy(err);
+				reject(`handshake failed (${err.message})`);
 				return;
 			}
-			const client = new ws.Socket({
+			const raw = new ws.Socket({
 				socket,
-				isServer: true
+				isServer: true,
+				idleTimeout: wsDeadPeerTimeoutMs
+			});
+			const writer = createBoundedWriter(raw, {
+				maxQueuedBytes: wsMaxQueuedBytes,
+				onOverflow: () => {
+					console.error("[loopback] client is not reading and responses are backing up; closing the protocol socket");
+					raw.destroy();
+				}
 			});
+			const client = {
+				on: (event, listener) => raw.on(event, listener),
+				write: (data) => writer.write(data),
+				destroy: () => raw.destroy(),
+				pause: () => raw.pause?.(),
+				resume: () => raw.resume?.()
+			};
+			const previous = activeSocket;
 			activeSocket = client;
-			client.on("close", () => {
-				if (activeSocket === client) activeSocket = null;
+			activeWriter = writer;
+			activeSince = Date.now();
+			if (previous) {
+				console.warn("[loopback] replaced the existing protocol socket");
+				try {
+					previous.destroy();
+				} catch {
+					debugSkip("[static-server] replace: previous socket already closed");
+				}
+			}
+			raw.on("close", () => {
+				writer.clear();
+				if (activeSocket === client) {
+					activeSocket = null;
+					activeWriter = null;
+				}
 			});
-			socket.setTimeout(wsIdleTimeoutMs, () => client.destroy());
+			socket.setTimeout(wsIdleTimeoutMs, () => raw.destroy());
 			for (const handler of connectionHandlers) try {
 				handler(client, req);
 			} catch (e) {
@@ -470,7 +1025,8 @@ function createLoopbackServer(options = {}) {
 			return {
 				origin: originUrl,
 				port: Number(originUrl.slice(originUrl.lastIndexOf(":") + 1)),
-				token
+				token,
+				bootstrap: bootstrapNonce
 			};
 		},
 		mount(path, filePath) {
@@ -479,8 +1035,10 @@ function createLoopbackServer(options = {}) {
 		unmount(path) {
 			fileMounts.delete(path);
 		},
-		mountDir(prefix, dirPath) {
+		mountDir(prefix, dirPath, opts) {
 			dirMounts.set(prefix, dirPath);
+			if (opts?.public) publicDirMounts.add(prefix);
+			else publicDirMounts.delete(prefix);
 		},
 		onConnection(handler) {
 			connectionHandlers.push(handler);
@@ -489,29 +1047,128 @@ function createLoopbackServer(options = {}) {
 			routeHandlers.set(`${method.toUpperCase()} ${path}`, handler);
 		},
 		push(frame) {
-			if (!activeSocket) return false;
+			if (!activeWriter) return false;
 			try {
-				activeSocket.write(frame);
-				return true;
+				return activeWriter.write(frame, { droppable: true });
 			} catch {
+				debugSkip("[static-server] push: socket.write failed — frame dropped");
 				return false;
 			}
 		},
 		close(cb) {
 			if (activeSocket) try {
 				activeSocket.destroy();
-			} catch {}
+			} catch {
+				debugSkip("[static-server] close: socket.destroy failed — already closed");
+			}
 			server.close(cb);
 		}
 	};
 }
-//#endregion
-//#region core/server/websocket-server.ts
+// core/logs/routes.ts
+function queryParams(url) {
+	const out = {};
+	const query = (url ?? "").split("?")[1];
+	if (!query) return out;
+	for (const pair of query.split("&")) {
+		const eq = pair.indexOf("=");
+		if (eq === -1) continue;
+		const key = decodeURIComponent(pair.slice(0, eq));
+		out[key] = decodeURIComponent(pair.slice(eq + 1));
+	}
+	return out;
+}
+function formatText(e) {
+	const tag = e.tag ? `[${e.tag}] ` : "";
+	return `[${new Date(e.ts).toISOString()}] ${e.level.toUpperCase()} ${e.source} ${tag}${e.message}`;
+}
+/** Registers the loopback log routes on the unified server. They inherit the
+* server's auth gate and single-server rule for free:
+*
+* - `GET /logs?tail=&level=&source=&format=jsonl|text` — bulk read-back,
+*   deliberately off the framed invoke so there is no `MAX_HEADER_BYTES`
+*   ceiling.
+* - `POST /logs` — ingest for web/browser log batches (`{ source, entries }`).
+*/
+function registerLogRoutes(server, store) {
+	server.registerRoute("GET", "/logs", (req, res) => {
+		const params = queryParams(req.url);
+		const tail = params.tail === void 0 ? void 0 : Number(params.tail);
+		const level = params.level || void 0;
+		const source = params.source || void 0;
+		const entries = store.view({
+			tail: tail !== void 0 && Number.isFinite(tail) ? tail : void 0,
+			level,
+			source
+		});
+		const format = params.format === "jsonl" ? "jsonl" : "text";
+		res.writeHead(200, {
+			"Content-Type": format === "jsonl" ? "application/x-ndjson" : "text/plain",
+			"Referrer-Policy": "no-referrer",
+			"Cache-Control": "no-store"
+		});
+		if (format === "jsonl") {
+			const lines = entries.map((e) => JSON.stringify(e)).join("\n");
+			res.end(lines.length > 0 ? `${lines}\n` : "");
+		} else {
+			const lines = entries.map(formatText).join("\n");
+			res.end(lines.length > 0 ? `${lines}\n` : "");
+		}
+	});
+	server.registerRoute("POST", "/logs", (req, res) => {
+		collectRequestBody(req, 1048576).then((body) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(body);
+			} catch {
+				res.writeHead(400, {
+					"Content-Type": "text/plain",
+					"Referrer-Policy": "no-referrer"
+				});
+				res.end("Bad request");
+				return;
+			}
+			const source = parsed.source === "backend" ? "backend" : "web";
+			const batch = Array.isArray(parsed.entries) ? parsed.entries : [];
+			let accepted = 0;
+			for (const raw of batch) {
+				if (!raw || typeof raw.message !== "string") continue;
+				store.append({
+					ts: Date.now(),
+					level: raw.level ?? "info",
+					source,
+					tag: raw.tag,
+					message: raw.message
+				});
+				accepted++;
+			}
+			res.writeHead(200, {
+				"Content-Type": "application/json",
+				"Referrer-Policy": "no-referrer",
+				"Cache-Control": "no-store"
+			});
+			res.end(JSON.stringify({ accepted }));
+		}).catch((err) => {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error("Discarding oversized /logs batch:", message);
+			res.writeHead(413, {
+				"Content-Type": "text/plain",
+				"Referrer-Policy": "no-referrer"
+			});
+			res.end("Request Entity Too Large");
+		});
+	});
+}
+// core/server/websocket-server.ts
 function toUint8Array$1(data) {
 	if (data instanceof Uint8Array) return data;
 	if (data instanceof ArrayBuffer) return new Uint8Array(data);
 	throw new Error("Expected Uint8Array or ArrayBuffer from socket data");
 }
+/** Envelope encoder bound to a loopback server's connected protocol socket —
+* the server-initiated (backend → web) push seam. */
+/** Routed calls pending on one socket before it stops being read. */
+const MAX_PENDING_ROUTES = 32;
 /** Builds the push seam for the server's connected protocol socket: encodes a
 * `DISPATCH`-style envelope and writes it, mirroring how `attachWebSocketProtocol`
 * writes responses. Returns false when no socket is connected. */
@@ -530,23 +1187,48 @@ function createLoopbackPush(server, protocol) {
 function attachWebSocketProtocol(server, context) {
 	const { protocol, pluginRouter } = context;
 	server.onConnection((socket, _request) => {
-		socket.on("data", async (raw) => {
-			try {
-				const data = toUint8Array$1(raw);
-				if (data.byteLength === 0) return;
-				const parsed = protocol.decode(data);
-				const header = parsed.header;
-				const pluginResponse = await pluginRouter.route(header, parsed.payload);
-				if (pluginResponse) socket.write(protocol.encode(MessageType.ENVELOPE, pluginResponse, null));
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				console.error("Error handling WebSocket message:", message);
+		const decoder = createFrameDecoder(protocol);
+		const gate = createInboundGate({
+			high: MAX_PENDING_ROUTES,
+			low: MAX_PENDING_ROUTES / 2,
+			pause: () => socket.pause?.(),
+			resume: () => socket.resume?.()
+		});
+		socket.on("data", (raw) => {
+			const data = toUint8Array$1(raw);
+			if (data.byteLength === 0) {
+				console.debug("[ws] received empty data chunk, ignoring");
+				return;
+			}
+			const messages = decoder.push(data);
+			if (decoder.error) {
+				console.error("Error handling WebSocket message: " + decoder.error.message);
+				socket.destroy();
+				return;
 			}
+			if (messages.length === 0) return;
+			for (const parsed of messages) {
+				const work = pluginRouter.route(parsed.header, parsed.payload).then((pluginResponse) => {
+					if (pluginResponse) socket.write(encodeResponse(protocol, pluginResponse));
+				}).catch((err) => {
+					const message = err instanceof Error ? err.message : String(err);
+					console.error("Error handling WebSocket message:", message);
+				});
+				gate.track(work);
+			}
+		});
+		socket.on("close", () => {
+			decoder.clear();
+		});
+		socket.on("error", (err) => {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error("WebSocket connection error:", message);
+			decoder.clear();
+			socket.destroy();
 		});
 	});
 }
-//#endregion
-//#region core/runtime.ts
+// core/runtime.ts
 function readBareArgv() {
 	return typeof Bare !== "undefined" && Array.isArray(Bare.argv) ? Bare.argv : [];
 }
@@ -574,7 +1256,9 @@ function resolveWorkletConfig() {
 				cache: cacheDir
 			};
 		}
-	} catch {}
+	} catch (err) {
+		console.debug(`[runtime] config dir check failed; not a device configuration: ` + (err instanceof Error ? err.message : String(err)));
+	}
 	return resolveCliConfig(argv);
 }
 /**
@@ -633,7 +1317,7 @@ function toUint8Array(data) {
 	return new Uint8Array(data);
 }
 function writeIpc(ipc, bytes) {
-	if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") ipc.write(Buffer.from(bytes));
+	if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") ipc.write(Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes));
 	else ipc.write(bytes);
 }
 /**
@@ -646,14 +1330,17 @@ function createWorkletRuntime(options = {}) {
 	const deviceMode = options.deviceMode ?? options.storage !== void 0;
 	const auth = options.auth ?? deviceMode;
 	const port = options.port ?? (deviceMode ? 0 : 8080);
+	const textEncoder = new TextEncoder();
+	const textDecoder = new TextDecoder();
 	const protocol = new MessageProtocol({
-		encode: (str) => new TextEncoder().encode(str),
-		decode: (bytes) => new TextDecoder().decode(bytes)
+		encode: (str) => textEncoder.encode(str),
+		decode: (bytes) => textDecoder.decode(bytes)
 	});
 	let ipc;
 	try {
 		ipc = getIPC();
-	} catch {
+	} catch (err) {
+		console.debug(`[runtime] no host IPC channel available, running without a host: ` + (err instanceof Error ? err.message : String(err)));
 		ipc = void 0;
 	}
 	const hostBridge = ipc ? createHostIpcBridge({
@@ -665,41 +1352,70 @@ function createWorkletRuntime(options = {}) {
 		host: options.host,
 		port,
 		auth,
-		wsIdleTimeoutMs: options.wsIdleTimeoutMs
+		wsIdleTimeoutMs: options.wsIdleTimeoutMs,
+		wsDeadPeerTimeoutMs: options.wsDeadPeerTimeoutMs,
+		wsReplaceMinIntervalMs: options.wsReplaceMinIntervalMs,
+		wsMaxQueuedBytes: options.wsMaxQueuedBytes
 	});
+	const logStore = createLogRingBuffer(options.logsCapacity ?? 500);
+	installConsoleCapture(logStore, "backend", { minLevel: options.logsMinLevel });
+	registerLogRoutes(server, logStore);
 	for (const plugin of createDefaultPlugins({
 		listBareCapabilities: () => pluginRegistry.listCapabilities(),
 		queryHostCapabilities: () => hostBridge?.queryCapabilities() ?? Promise.resolve([]),
 		staticServer: server,
-		invokeOnHost: (header, payload) => hostBridge?.invokeOnHost(header, payload) ?? Promise.resolve(null)
+		invokeOnHost: (header, payload) => hostBridge?.invokeOnHost(header, payload) ?? Promise.resolve(null),
+		store: logStore
 	})) pluginRegistry.register(plugin);
 	for (const plugin of options.plugins ?? []) pluginRegistry.register(plugin);
-	const pluginRouter = createPluginRouter(pluginRegistry, "bare", { delegateToHost: (header, payload) => hostBridge?.invokeOnHost(header, payload) ?? Promise.resolve(null) });
-	if (ipc) ipc.on("data", async (data) => {
-		try {
-			const raw = toUint8Array(data);
-			if (hostBridge?.tryConsumeDownstreamFromHost(raw)) return;
-			const parsed = protocol.decode(raw);
-			const header = parsed.header;
-			const pluginResponse = await pluginRouter.route(header, parsed.payload);
-			if (pluginResponse) writeIpc(ipc, protocol.encode(MessageType.ENVELOPE, pluginResponse, null));
-		} catch (e) {
-			const message = e instanceof Error ? e.message : String(e);
-			console.error(`Malformed IPC frame dropped: ${message}`);
-		}
+	const pluginRouter = createPluginRouter(pluginRegistry, "bare", {
+		maxInflight: options.maxInflight,
+		serialPlugins: options.serialPlugins,
+		delegateToHost: (header, payload) => hostBridge?.invokeOnHost(header, payload) ?? Promise.resolve(null),
+		getHostCapabilities: () => hostBridge?.queryCapabilities() ?? Promise.resolve([])
 	});
+	if (ipc) {
+		const ipcDecoder = createFrameDecoder(protocol);
+		const ipcHealth = new ChannelHealth();
+		ipc.on("data", (data) => {
+			if (ipcHealth.isFatal) return;
+			const messages = ipcDecoder.push(toUint8Array(data));
+			if (ipcDecoder.error) {
+				console.error(`Malformed IPC frame dropped: ${ipcDecoder.error.message}`);
+				if (ipcHealth.noteFailure()) {
+					console.error("IPC channel permanently desynced after repeated malformed frames; stopping host→worklet frame parsing");
+					return;
+				}
+				ipcDecoder.clear();
+				return;
+			}
+			ipcHealth.noteSuccess();
+			if (messages.length === 0) return;
+			for (const parsed of messages) {
+				if (hostBridge?.tryConsumeDownstream(parsed)) continue;
+				pluginRouter.route(parsed.header, parsed.payload).then((pluginResponse) => {
+					if (pluginResponse) writeIpc(ipc, encodeResponse(protocol, pluginResponse));
+				}).catch((err) => {
+					const message = err instanceof Error ? err.message : String(err);
+					console.error(`Malformed IPC frame dropped: ${message}`);
+				});
+			}
+		});
+	}
 	async function start() {
 		if (options.storage) try {
 			fs.rmSync(path.join(options.storage, "handoff.json"), { force: true });
-		} catch {}
-		if (options.webAssets) server.mountDir("/", options.webAssets);
+		} catch {
+			console.debug("[runtime] no existing handoff file to remove");
+		}
+		if (options.webAssets) server.mountDir("/", options.webAssets, { public: true });
 		attachWebSocketProtocol(server, {
 			protocol,
 			pluginRegistry,
 			pluginRouter
 		});
 		const credentials = await server.credentials();
-		if (auth && options.storage) try {
+		if (auth && options.storage && options.handoffFile !== false) try {
 			fs.writeFileSync(path.join(options.storage, "handoff.json"), JSON.stringify(credentials));
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
@@ -725,5 +1441,4 @@ function createWorkletRuntime(options = {}) {
 		}
 	};
 }
-//#endregion
 export { attachWebSocketProtocol, collectRequestBody, createLoopbackPush, createLoopbackServer, createWorkletRuntime, getIPC, resolveCliConfig, resolveWorkletConfig };