@linxiraos/pi-utils 1.4.4 → 1.4.7

package/src/logger.ts

@@ -7,11 +7,13 @@
  * transport so a process supervisor (pm2, journald, k8s) captures the logs.
  *
  * Each entry includes `process.pid` so concurrent zeta instances stay
- * traceable. The file is created on the first record written. Records are
- * batched — one write per second or per 64 KiB — while `warn`/`error` records
- * are written at once together with everything buffered before them; exit,
- * fatal, and signal paths flush the rest. `ZETA_LOG_LEVEL` optionally limits
- * the levels written to the file (default: all).
+ * traceable, and the fields of the enclosing {@link withContext} (a session's
+ * `sessionId`) so sessions sharing one process stay apart. The file is created
+ * on the first record written. Records are batched — one write per second or
+ * per 64 KiB — while `warn`/`error` records are written at once together with
+ * everything buffered before them; exit, fatal, and signal paths flush the
+ * rest. `ZETA_LOG_LEVEL` optionally limits the levels written to the file
+ * (default: all).
  */
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as fs from "node:fs";
@@ -48,7 +50,18 @@ export function registerLogSink(sink: LogSink): () => void {
 
 function emitToSinks(level: LogLevel, message: string, context: Record<string, unknown> | undefined): void {
 	if (logSinks.size === 0) return;
-	const event: LogEvent = { level, message, context, timestamp: new Date() };
+	// The enclosing {@link withContext} fields reach sinks as they reach the file;
+	// call-site fields win, and a record outside any context keeps its own object.
+	const scoped = logContextStorage.getStore();
+	let merged = context;
+	if (scoped) {
+		try {
+			merged = { ...scoped, ...context };
+		} catch {
+			// A throwing getter must not turn a log call into a failure; sinks get the call's own fields.
+		}
+	}
+	const event: LogEvent = { level, message, context: merged, timestamp: new Date() };
 	for (const sink of logSinks) {
 		try {
 			sink(event);
@@ -251,6 +264,28 @@ function formatLocalTimestamp(date: Date): string {
 
 const FORMAT_TOKEN_PATTERN = /%[scdjifoO%]/;
 
+const logContextStorage = new AsyncLocalStorage<Readonly<Record<string, unknown>>>();
+
+/**
+ * Run `fn` with `context`'s fields on every record logged while it runs,
+ * including from the promises, timers and callbacks it starts. A nested call
+ * replaces the enclosing context, as a subagent's session replaces its
+ * parent's; a field passed to the log call itself wins. Fields are read as each
+ * record is written, so a getter stays current.
+ */
+export function withContext<T>(context: Readonly<Record<string, unknown>>, fn: () => T): T {
+	return logContextStorage.run(context, fn);
+}
+
+/**
+ * Run `fn` outside any {@link withContext}: for process-wide work started on
+ * behalf of one caller, such as a shared server's read loop, whose later
+ * records belong to no single caller.
+ */
+export function withoutContext<T>(fn: () => T): T {
+	return logContextStorage.exit(fn);
+}
+
 /** Serialize one log record: timestamp, level, pid, message, then context fields. */
 function formatLogRecord(
 	level: LogLevel,
@@ -266,6 +301,12 @@ function formatLogRecord(
 		pid: process.pid,
 		message: metadata?.message ? `${message} ${metadata.message}` : message,
 	};
+	const scoped = logContextStorage.getStore();
+	if (scoped) {
+		for (const key of Object.keys(scoped)) {
+			if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = scoped[key];
+		}
+	}
 	if (metadata) {
 		for (const key of Object.keys(metadata)) {
 			if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = metadata[key];

package/src/marked/core.ts

@@ -655,39 +655,48 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 	// The context is shared with the sources nested in this one, which move its end while they are lexed.
 	context.end = closers.end;
 	let rest = lex.rest;
+	// A token the lexer consumed ends the walk, so the backticks left where the next token starts are a string of their
+	// own even when the run they belong to began earlier: an extension, an override or an escape token may leave the
+	// scan inside a run, and a code span opens there. Only the text step's own advance leaves the scan inside a run
+	// without consuming a token, and no span opens at such a position.
+	let resumed = false;
+	/** Pushes `token` and moves past its raw, which is where the next token starts. */
+	const consumeToken = (token: Token): void => {
+		output.push(token);
+		rest = rest.slice(token.raw.length);
+		resumed = true;
+	};
 	while (rest !== "") {
+		const resumedHere = resumed;
+		resumed = false;
 		let custom: Tokens.Generic | undefined;
 		for (const extension of lexer.extensions.inline) {
 			custom = extension.tokenizer.call(context, rest, output);
 			if (custom?.raw) break;
 		}
 		if (custom?.raw) {
-			output.push(custom);
-			rest = rest.slice(custom.raw.length);
+			consumeToken(custom);
 			continue;
 		}
 
 		const escaped = /^\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/.exec(rest);
 		if (escaped) {
-			output.push({ type: "escape", raw: escaped[0], text: escaped[1]! });
-			rest = rest.slice(2);
+			consumeToken({ type: "escape", raw: escaped[0], text: escaped[1]! });
 			continue;
 		}
 		const br = lexer.options.breaks ? /^(?: {2,}|\\)?\n/.exec(rest) : /^(?: {2,}|\\)\n/.exec(rest);
 		if (br) {
-			output.push({ type: "br", raw: br[0] });
-			rest = rest.slice(br[0].length);
+			consumeToken({ type: "br", raw: br[0] });
 			continue;
 		}
 		if (rest[0] === "`") {
-			const width = closers.codeOpenerWidth(rest);
+			const width = closers.codeOpenerWidth(rest, resumedHere);
 			const end = closers.closeCode(rest, width);
 			if (end !== -1) {
 				const raw = rest.slice(0, end + width);
 				let text = rest.slice(width, end).replace(/\n/g, " ");
 				if (/^ .* $/.test(text) && text.trim() !== "") text = text.slice(1, -1);
-				output.push({ type: "codespan", raw, text });
-				rest = rest.slice(raw.length);
+				consumeToken({ type: "codespan", raw, text });
 				continue;
 			}
 		}
@@ -695,14 +704,12 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 		if (auto) {
 			const text = auto.slice(1, -1);
 			const href = text.includes("@") && !/^[a-z][a-z+.-]*:\/\//i.test(text) ? `mailto:${text}` : text;
-			output.push({ type: "link", raw: auto, text, href, tokens: [{ type: "text", raw: text, text }] });
-			rest = rest.slice(auto.length);
+			consumeToken({ type: "link", raw: auto, text, href, tokens: [{ type: "text", raw: text, text }] });
 			continue;
 		}
 		const html = inlineHtmlPrefix(rest, closers);
 		if (html) {
-			output.push({ type: "html", raw: html, inLink: false, inRawBlock: false, block: false, text: html });
-			rest = rest.slice(html.length);
+			consumeToken({ type: "html", raw: html, inLink: false, inRawBlock: false, block: false, text: html });
 			continue;
 		}
 		const nested = matchLink(rest, lexer, closers) ?? matchEmphasis(rest, output, closers);
@@ -716,8 +723,7 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 			if (override) del = override.call(lexer.tokenizer, rest, rest);
 			if (del === false || !override) del = lexer.tokenizer.del(rest);
 			if (del) {
-				output.push(del);
-				rest = rest.slice(del.raw.length);
+				consumeToken(del);
 				continue;
 			}
 		}
@@ -744,8 +750,7 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 			}
 		}
 		if (url) {
-			output.push(url);
-			rest = rest.slice(url.raw.length);
+			consumeToken(url);
 			continue;
 		}
 

package/src/marked/inline-closers.ts

@@ -170,38 +170,30 @@ class EmphasisDelimiters {
 
 /**
  * The runs of backticks in the root source, for the code span rule. A span opened by `width` backticks closes at the
- * first `width` backticks after its opening run that no backslash escapes: the start of a later run of at least
- * `width`, or, in a run whose first backtick a backslash escapes, the backticks from its `width`th on, since the
- * search for a closer goes on `width` past an escaped one.
+ * next run of exactly `width` backticks: a run of any other length is no closer, and the one that closes is the first
+ * run of that width at or after the opener. Backslash escapes do not apply inside a code span, so a backslash just
+ * before that closing backtick is content and still closes the span.
  */
 class CodeRuns {
-	// Per run, in order: where it starts and ends, and whether a backslash escapes it.
+	// Per run, in order: where it starts and ends; the starts are the binary search `endOf` and `startsStringAt` need.
 	readonly #starts: number[] = [];
 	readonly #ends: number[] = [];
-	readonly #escaped: boolean[] = [];
-	// A segment tree over the runs of the widest closer each run holds: its length, or half of it when escaped.
-	readonly #widest: Int32Array;
-	readonly #leaves: number;
+	// Run starts by width, each list ascending: a closer must have the opener's exact width, so finding one is a
+	// binary search in the list for that width and no scan of the runs between.
+	readonly #byWidth = new Map<number, number[]>();
 
 	constructor(src: string) {
-		const widths: number[] = [];
 		for (let at = src.indexOf("`"); at !== -1;) {
 			let end = at + 1;
 			while (src.charCodeAt(end) === 0x60 /* ` */) end++;
-			const escaped = escapedAt(src, at);
 			this.#starts.push(at);
 			this.#ends.push(end);
-			this.#escaped.push(escaped);
-			widths.push(escaped ? (end - at) >> 1 : end - at);
+			const width = end - at;
+			const starts = this.#byWidth.get(width);
+			if (starts === undefined) this.#byWidth.set(width, [at]);
+			else starts.push(at);
 			at = src.indexOf("`", end);
 		}
-		let leaves = 1;
-		while (leaves < widths.length) leaves <<= 1;
-		const widest = new Int32Array(2 * leaves);
-		for (let run = 0; run < widths.length; run++) widest[leaves + run] = widths[run]!;
-		for (let node = leaves - 1; node >= 1; node--) widest[node] = Math.max(widest[2 * node]!, widest[2 * node + 1]!);
-		this.#widest = widest;
-		this.#leaves = leaves;
 	}
 
 	/** Where the run of backticks holding the backtick at `at` ends. */
@@ -209,28 +201,24 @@ class CodeRuns {
 		return this.#ends[lowerBound(this.#starts, at + 1) - 1]!;
 	}
 
+	/**
+	 * Whether a backtick string starts at `at` for a scan that walked to `at`: a string is a whole run, so it starts at
+	 * the run's first backtick and nowhere else. A retry deeper inside a run is not a string, which keeps a run whose
+	 * opener found no closer from opening a narrower span one backtick later. A position a tokenizer's raw resumed at,
+	 * or the suffix an escape token left behind, is not a walked position — `codeOpenerWidth` admits those on its own,
+	 * because it is told the scan resumed there rather than inferring it from the source text.
+	 */
+	startsStringAt(at: number): boolean {
+		const run = lowerBound(this.#starts, at + 1) - 1;
+		return this.#starts[run] === at;
+	}
+
 	/** Where the closer of a code span opened by `width` backticks that end at `from` starts, or -1. */
 	closerAfter(from: number, width: number): number {
-		const run = this.#firstHolding(lowerBound(this.#starts, from), width);
-		return run === -1 ? -1 : this.#starts[run]! + (this.#escaped[run] ? width : 0);
-	}
-
-	/** The first run at or after `first` that holds a closer of `width` backticks, or -1. */
-	#firstHolding(first: number, width: number): number {
-		if (first >= this.#starts.length) return -1;
-		const widest = this.#widest;
-		const leaves = this.#leaves;
-		let node = leaves + first;
-		if (widest[node]! >= width) return first;
-		// Up to the nearest subtree on the right that holds one, then down to its first run that does.
-		for (;;) {
-			if (node === 1) return -1;
-			if ((node & 1) === 0 && widest[node + 1]! >= width) break;
-			node >>= 1;
-		}
-		node++;
-		while (node < leaves) node = widest[2 * node]! >= width ? 2 * node : 2 * node + 1;
-		return node - leaves;
+		const starts = this.#byWidth.get(width);
+		if (starts === undefined) return -1;
+		const run = lowerBound(starts, from);
+		return run < starts.length ? starts[run]! : -1;
 	}
 }
 
@@ -388,10 +376,17 @@ export class InlineClosers {
 		return close === -1 ? -1 : close - pos;
 	}
 
-	/** How many backticks start `rest`, which starts with one. */
-	codeOpenerWidth(rest: string): number {
+	/**
+	 * How many backticks start `rest`, which starts with one, or 0 where no code span opens because no backtick string
+	 * starts there: the opener is a whole string, so the rest of a run whose opener found no closer is text, while the
+	 * backticks left after a backslash escaped the run's first one do open a span. `resumed` says the scan resumed at
+	 * `rest` after a tokenizer consumed a raw that ended here, where the backticks are a string wherever they sit.
+	 */
+	codeOpenerWidth(rest: string, resumed = false): number {
 		const pos = this.end - rest.length;
-		return Math.min(this.#indexes.codeRuns.endOf(pos), this.end) - pos;
+		const runs = this.#indexes.codeRuns;
+		if (!resumed && !runs.startsStringAt(pos)) return 0;
+		return Math.min(runs.endOf(pos), this.end) - pos;
 	}
 
 	/** Where the code span opened by the `width` backticks at the start of `rest` closes, or -1. */

package/src/mime.ts

@@ -11,6 +11,7 @@ const GIF89A = Buffer.from("GIF89a");
 const WEBP_VP8X = Buffer.from("VP8X");
 const WEBP_VP8L = Buffer.from("VP8L");
 const WEBP_VP8 = Buffer.from("VP8 ");
+const FTYP = Buffer.from("ftyp");
 
 export const SUPPORTED_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 
@@ -143,6 +144,40 @@ export function parseImageMetadata(header: Uint8Array): ImageMetadata | null {
 	);
 }
 
+/** Still images in a HEIF (ISO BMFF) container, which the image pipeline cannot decode itself. */
+export type HeifImageMimeType = "image/heic" | "image/heif" | "image/avif";
+
+const HEIF_BRAND_MIME_TYPES: Readonly<Record<string, HeifImageMimeType>> = {
+	heic: "image/heic",
+	heix: "image/heic",
+	heim: "image/heic",
+	heis: "image/heic",
+	hevc: "image/heic",
+	hevx: "image/heic",
+	avif: "image/avif",
+	avis: "image/avif",
+	mif1: "image/heif",
+	msf1: "image/heif",
+};
+
+/**
+ * MIME type of a HEIC, AVIF or other HEIF image from the brands of its leading `ftyp` box:
+ * the major brand, then the compatible brands, with the generic `mif1`/`msf1` brands last.
+ */
+export function parseHeifImageMimeType(header: Uint8Array): HeifImageMimeType | null {
+	if (!magicEquals(header, 4, FTYP)) return null;
+	const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+	const boxEnd = Math.min(view.getUint32(0, false), header.length);
+	let generic: HeifImageMimeType | null = null;
+	// The major brand sits at 8 and the compatible brands start at 16, after the minor version.
+	for (let offset = 8; offset + 4 <= boxEnd; offset += offset === 8 ? 8 : 4) {
+		const mimeType = HEIF_BRAND_MIME_TYPES[String.fromCharCode(...header.subarray(offset, offset + 4))];
+		if (mimeType === "image/heif") generic ??= mimeType;
+		else if (mimeType) return mimeType;
+	}
+	return generic;
+}
+
 /** Why base64 image data is unusable; `undefined` when it is canonical and non-empty. */
 export type Base64ImageDataFailure = "invalid base64 image data" | "empty image data";
 

package/src/ports.ts

@@ -3,8 +3,9 @@
  *
  * OMP installs on the same machine use 30141/30142/3847, and common developer
  * tools squat on 3000/8080/8787/3847. Zeta therefore owns a dedicated block:
- * three uncommon ports, at least two apart, so a side-by-side OMP install and
- * unrelated services cannot take the gateway or the stats dashboard away.
+ * uncommon ports, at least two apart, so a side-by-side OMP install and
+ * unrelated services cannot take the gateway, stats dashboard, or browser
+ * relay away.
  *
  * Every default in the repository derives from these constants. The standalone
  * Electron shell (`desktop/src/main.ts`, not a Bun workspace package) carries
@@ -13,3 +14,4 @@
 export const ZETA_WEB_PORT = 43141;
 export const ZETA_GATEWAY_PORT = 43143;
 export const ZETA_STATS_PORT = 43147;
+export const ZETA_BROWSER_RELAY_PORT = 43153;