@oh-my-pi/pi-utils 18.6.3 → 18.8.0

package/src/json-parse.ts

@@ -309,15 +309,30 @@ export function parseJsonWithRepair<T>(json: string): T {
 export function parseStreamingJson<T = Record<string, unknown>>(partialJson: string | undefined): T {
 	const trimmed = partialJson?.trimStart();
 	if (!trimmed) return {} as T;
+	// A container can only be strict JSON once its closer arrived; skip the
+	// doomed full-buffer JSON.parse (and its SyntaxError) while it streams.
+	const first = trimmed.charCodeAt(0);
+	if ((first !== 0x7b && first !== 0x5b) || canCloseContainer(trimmed)) {
+		try {
+			return JSON.parse(trimmed) as T;
+		} catch {}
+	}
 	try {
-		return JSON.parse(trimmed) as T;
+		return (new RelaxedJson(trimmed, true).parse() ?? {}) as T;
 	} catch {
-		try {
-			return (new RelaxedJson(trimmed, true).parse() ?? {}) as T;
-		} catch {
-			return {} as T;
-		}
+		return {} as T;
+	}
+}
+
+/** True when the last non-whitespace character is `}` or `]`. */
+function canCloseContainer(text: string): boolean {
+	for (let i = text.length - 1; i >= 0; i--) {
+		const code = text.charCodeAt(i);
+		// JSON whitespace: space, \t, \n, \r
+		if (code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d) continue;
+		return code === 0x7d || code === 0x5d;
 	}
+	return false;
 }
 
 /**

package/src/logger/rotating-file.ts

@@ -109,11 +109,13 @@ export class RotatingFileSink {
 	/**
 	 * Append one already-formatted log record. A batching sink buffers it unless
 	 * `flushNow` is set or the buffer reached its size threshold; either way the
-	 * whole buffer, this record included, is then written in order.
+	 * whole buffer, this record included, is then written in order. `day` is the
+	 * record's `localDay` key, so callers that already took the record's `Date`
+	 * reuse it.
 	 */
-	write(line: string, flushNow = false): void {
+	write(line: string, flushNow = false, day = localDay(new Date())): void {
 		if (this.#closed) return;
-		this.#selectFile(localDay(new Date()));
+		this.#selectFile(day);
 		const record = `${line}${os.EOL}`;
 		const bytes = Buffer.byteLength(record, "utf8");
 		this.#pending += record;

package/src/logger.ts

@@ -209,9 +209,28 @@ function jsonReplacer(_key: string, value: unknown): unknown {
 	return value;
 }
 
-interface NormalizedLogInfo extends Record<string, unknown> {
-	level: LogLevel;
-	message: unknown;
+// Values visited by the Error pre-scan before falling back to the replacer.
+const ERROR_SCAN_BUDGET = 128;
+
+/**
+ * Whether `value` may contain an {@link Error} that {@link jsonReplacer} must
+ * unwrap. Walks what `JSON.stringify` serializes (arrays and own enumerable
+ * keys); objects with a `toJSON` other than `Date` may return an Error, and an
+ * exhausted budget answers true.
+ */
+function mayContainError(root: unknown): boolean {
+	const stack: unknown[] = [root];
+	let budget = ERROR_SCAN_BUDGET;
+	while (stack.length > 0) {
+		const value = stack.pop();
+		if (value === null || typeof value !== "object") continue;
+		if (value instanceof Error) return true;
+		if (--budget < 0) return true;
+		if (value instanceof Date) continue;
+		if ("toJSON" in value && typeof value.toJSON === "function") return true;
+		for (const child of Object.values(value)) stack.push(child);
+	}
+	return false;
 }
 
 function padTimestampPart(value: number, width = 2): string {
@@ -232,33 +251,30 @@ function formatLocalTimestamp(date: Date): string {
 
 const FORMAT_TOKEN_PATTERN = /%[scdjifoO%]/;
 
-function normalizeLogInfo(
+/** Serialize one log record: timestamp, level, pid, message, then context fields. */
+function formatLogRecord(
 	level: LogLevel,
 	message: string,
 	context: Record<string, unknown> | undefined,
-): NormalizedLogInfo {
+	timestamp: string,
+): string {
 	const metadata =
 		!FORMAT_TOKEN_PATTERN.test(message) && context !== null && typeof context === "object" ? context : undefined;
-	const info = Object.assign({}, metadata, { level, message }) as NormalizedLogInfo;
-	if (metadata?.message) info.message = `${message} ${metadata.message}`;
-	if (metadata?.stack) info.stack = metadata.stack;
-	if (metadata?.cause) info.cause = metadata.cause;
-	return info;
-}
-
-function formatLogInfo(info: NormalizedLogInfo): string {
-	const timestamp = formatLocalTimestamp(new Date());
-	info.timestamp = timestamp;
 	const entry: Record<string, unknown> = {
 		timestamp,
-		level: info.level,
+		level,
 		pid: process.pid,
-		message: info.message,
+		message: metadata?.message ? `${message} ${metadata.message}` : message,
 	};
-	for (const [key, value] of Object.entries(info)) {
-		if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = value;
+	if (metadata) {
+		for (const key of Object.keys(metadata)) {
+			if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = metadata[key];
+		}
+		// An Error passed as the context carries these as non-enumerable fields.
+		if (metadata.stack) entry.stack = metadata.stack;
+		if (metadata.cause) entry.cause = metadata.cause;
 	}
-	return JSON.stringify(entry, jsonReplacer) as string;
+	return mayContainError(entry) ? JSON.stringify(entry, jsonReplacer) : JSON.stringify(entry);
 }
 
 /** Longest a buffered file record waits before it is written. */
@@ -361,9 +377,9 @@ function emitLocally(level: LogLevel, message: string, context: Record<string, u
 	const rank = LOG_LEVEL_RANK[level];
 	const file = rank <= transports.fileLevelRank ? transports.file : undefined;
 	if (!file && !transports.console) return;
-	const info = normalizeLogInfo(level, message, context);
-	const line = formatLogInfo(info);
-	file?.write(line, rank <= IMMEDIATE_FLUSH_RANK || exiting);
+	const now = new Date();
+	const line = formatLogRecord(level, message, context, formatLocalTimestamp(now));
+	file?.write(line, rank <= IMMEDIATE_FLUSH_RANK || exiting, localDay(now));
 	if (transports.console) fs.writeSync(1, `${line}${os.EOL}`);
 }
 

package/src/marked/core.ts

@@ -248,14 +248,15 @@ export type TokensList = Token[] & { links: Links };
 export interface TokenizerThis {
 	lexer: Lexer;
 	/**
-	 * For an inline tokenizer, the whole inline source, such as a paragraph's text. The `src` it receives is the part
-	 * of it before `end` that starts at `end - src.length`: inside a link label or the text of emphasis, `end` is where
-	 * that text ends, right before its closer, and a token there must not reach past it. Inline tokenizers get one
-	 * context object per inline source, the same for every call while the lexer works through it and the labels and
-	 * emphasis inside it, so a tokenizer can keep state for it in a `WeakMap`.
+	 * The whole source the lexer works through. The `src` a tokenizer receives is the part of it before `end` that
+	 * starts at `end - src.length`. For a block tokenizer, `source` is the text passed to one `blockTokens` call and
+	 * `end` its length. For an inline tokenizer, it is the inline source, such as a paragraph's text: inside a link
+	 * label or the text of emphasis, `end` is where that text ends, right before its closer, and a token there must
+	 * not reach past it. Tokenizers get one context object per source, the same for every call while the lexer works
+	 * through it (and, inline, the labels and emphasis inside it), so a tokenizer can keep state for it in a `WeakMap`.
 	 */
 	source?: string;
-	/** For an inline tokenizer, where the text the lexer works through ends in `source` (see `source`). */
+	/** Where the text the lexer works through ends in `source` (see `source`). */
 	end?: number;
 }
 /** A tokenizer extension callback. */
@@ -971,13 +972,30 @@ function parseList(lines: string[], index: number, lexer: Lexer): { token: Token
 
 function blockTokens(src: string, lexer: Lexer, output: Token[]): Token[] {
 	const lines = lineArray(src);
+	// `lines` tiles `src` exactly, so the unconsumed source at line `i` is
+	// `src.slice(lineStarts[i])`. Only block extensions and an lheading override
+	// read it; computing offsets once keeps the loop linear.
+	const blockExtensions = lexer.extensions.block;
+	const context: TokenizerThis = { lexer, source: src, end: src.length };
+	const lheadingOverride = lexer.tokenizerOverrides.lheading;
+	let lineStarts: number[] | undefined;
+	if (blockExtensions.length > 0 || lheadingOverride) {
+		lineStarts = [];
+		let offset = 0;
+		for (let index = 0; index < lines.length; index++) {
+			lineStarts.push(offset);
+			offset += lines[index]!.length;
+		}
+	}
 	let i = 0;
 	while (i < lines.length) {
-		const remaining = lines.slice(i).join("");
 		let custom: Tokens.Generic | undefined;
-		for (const extension of lexer.extensions.block) {
-			custom = extension.tokenizer.call({ lexer }, remaining, output);
-			if (custom?.raw) break;
+		if (blockExtensions.length > 0) {
+			const remaining = src.slice(lineStarts![i]);
+			for (const extension of blockExtensions) {
+				custom = extension.tokenizer.call(context, remaining, output);
+				if (custom?.raw) break;
+			}
 		}
 		if (custom?.raw) {
 			output.push(custom);
@@ -1006,9 +1024,10 @@ function blockTokens(src: string, lexer: Lexer, output: Token[]): Token[] {
 			let raw = line;
 			let text = "";
 			i++;
+			const closer = new RegExp(`^ {0,3}${marker[0]}{${marker.length},}[ \\t]*(?:\\n|$)$`);
 			while (i < lines.length) {
 				const next = lines[i++]!;
-				if (new RegExp(`^ {0,3}${marker[0]}{${marker.length},}[ \\t]*(?:\\n|$)$`).test(next)) {
+				if (closer.test(next)) {
 					raw += next;
 					break;
 				}
@@ -1090,10 +1109,16 @@ function blockTokens(src: string, lexer: Lexer, output: Token[]): Token[] {
 			i++;
 			if (line.trimStart().startsWith("<!--")) {
 				while (!raw.includes("-->") && i < lines.length) raw += lines[i++]!;
-			} else if (tag && !new RegExp(`</${tag}>`, "i").test(raw)) {
-				while (i < lines.length) {
-					raw += lines[i++]!;
-					if (new RegExp(`</${tag}>`, "i").test(raw)) break;
+			} else if (tag) {
+				// A closing tag never spans lines, so testing each appended line is
+				// equivalent to re-testing the accumulated block.
+				const closeTag = new RegExp(`</${tag}>`, "i");
+				if (!closeTag.test(raw)) {
+					while (i < lines.length) {
+						const next = lines[i++]!;
+						raw += next;
+						if (closeTag.test(next)) break;
+					}
 				}
 			}
 			const value = i < lines.length && /^\s*\n$/.test(lines[i]!) ? stripFinalNewline(raw) : raw;
@@ -1129,9 +1154,8 @@ function blockTokens(src: string, lexer: Lexer, output: Token[]): Token[] {
 		}
 		if (i + 1 < lines.length && /^ {0,3}(=+|-+)[ \t]*(?:\n|$)$/.test(lines[i + 1]!)) {
 			let fallback: Tokens.Heading | undefined | false;
-			const override = lexer.tokenizerOverrides.lheading;
-			if (override) fallback = override.call(lexer.tokenizer, remaining);
-			if (!override || fallback === false) {
+			if (lheadingOverride) fallback = lheadingOverride.call(lexer.tokenizer, src.slice(lineStarts![i]));
+			if (!lheadingOverride || fallback === false) {
 				const raw = line + lines[i + 1]!;
 				const text = stripFinalNewline(line);
 				const tokens: Token[] = [];

package/src/marked-list.ts

@@ -0,0 +1,73 @@
+/**
+ * List-continuation grammar of `@oh-my-pi/pi-utils/marked`, for streaming
+ * renderers that freeze a lexed prefix at blank-line boundaries (TUI and
+ * collab web).
+ *
+ * marked's list tokenizer (Tokenizer.list, marked v18) continues a list across
+ * blank lines only when the remaining source matches
+ * `listItemRegex(marker)` = `^( {0,3}${marker})((?:[\t ][^\n]*)?(?:\n|$))`,
+ * where `marker` is the exact bullet char for unordered lists (`\${char}`) or
+ * 1-9 digits plus the exact delimiter for ordered lists (`\d{1,9}\${delim}`).
+ * The marker is derived from the list's FIRST item (`n = t[1].trim()`), which
+ * sits at the start of a top-level list token's raw.
+ */
+
+/** A list's marker, read from the start of its raw: bullet in group 1, ordered delimiter in group 2. */
+const LIST_MARKER_RE = /^ {0,3}(?:([*+-])|\d{1,9}([.)]))/;
+
+/**
+ * Whether a same-marker item could still continue the list `listRaw` at
+ * `tailStart` (directly after the blank line ending the list), now or after
+ * any append to `text`.
+ *
+ * Streaming-freeze equivalence invariant: lex(prefix) ++ lex(tail) must equal
+ * lex(full text) for the current text and every append-only extension of it,
+ * because a frozen prefix is sticky. At a blank-line cut directly after a
+ * top-level `list` token, the only construct that can straddle the cut is a
+ * continuation item of that list: marked consumed the blank line into the last
+ * item's raw and re-ran `listItemRegex` at exactly `tailStart`, merging a
+ * same-marker item into one renumbered loose list. The cut is safe only when
+ * that regex can NEVER match at `tailStart`, no matter what is appended later.
+ *
+ * Append-only growth means "closed" may only be concluded from a present
+ * character that contradicts every possible continuation (tail "1x" can never
+ * grow into an ordered item, but tail "1" can become "1. c"). Running out of
+ * text mid-marker therefore answers "may continue".
+ *
+ * Returns true when the tail could still continue the list (or the list's
+ * marker is unrecognizable) — the conservative "don't freeze" answer. marked
+ * may break the list anyway when the matching line is also an hr (`- - -`);
+ * treating that as "may continue" merely skips a freeze, never corrupts one.
+ */
+export function listMayContinueAt(text: string, tailStart: number, listRaw: string): boolean {
+	const marker = LIST_MARKER_RE.exec(listRaw);
+	if (marker === null) return true; // unrecognized list shape — stay conservative
+	const n = text.length;
+	let i = tailStart;
+	// `listItemRegex` allows up to 3 leading spaces.
+	while (i < n && i - tailStart < 3 && text.charCodeAt(i) === 0x20 /* space */) i++;
+	if (i >= n) return true;
+	const bullet = marker[1];
+	if (bullet !== undefined) {
+		if (text[i] !== bullet) return false; // wrong marker char — closed forever
+		i++;
+	} else {
+		// Ordered: 1-9 digits, then the same `.`/`)` delimiter.
+		let digits = 0;
+		while (i < n && digits < 10) {
+			const c = text.charCodeAt(i);
+			if (c < 0x30 /* 0 */ || c > 0x39 /* 9 */) break;
+			digits++;
+			i++;
+		}
+		if (digits === 0 || digits > 9) return false; // no digit run / too long — closed forever
+		if (i >= n) return true; // delimiter (or more digits) may still arrive
+		if (text[i] !== marker[2]) return false; // wrong delimiter — closed forever
+		i++;
+	}
+	// After the marker: `(?:[\t ][^\n]*)?(?:\n|$)` — tab/space + anything, a
+	// bare newline, or end-of-input (which appends can still extend).
+	if (i >= n) return true;
+	const after = text.charCodeAt(i);
+	return after === 0x20 /* space */ || after === 0x09 /* tab */ || after === 0x0a; /* \n */
+}

package/src/math-delimiters.ts

@@ -235,6 +235,22 @@ export class MathBlockScan {
 	}
 }
 
+const blockScansByContext = new WeakMap<object, MathBlockScan>();
+
+/**
+ * The own-line display block at the start of `src`, for a marked block tokenizer: `src` is the part of
+ * `context.source` that starts at `context.end - src.length`. One {@link MathBlockScan} is kept per context, which
+ * marked keeps for one `blockTokens` source, so asking at every block start takes linear time even when an opener
+ * never closes. Without `context.source` it is {@link mathBlockAt}.
+ */
+export function mathBlockInContext(context: { source?: string; end?: number }, src: string): MathBlock | undefined {
+	const source = context.source;
+	if (source === undefined) return mathBlockAt(src);
+	let scan = blockScansByContext.get(context);
+	if (!scan) blockScansByContext.set(context, (scan = new MathBlockScan(source)));
+	return scan.at((context.end ?? source.length) - src.length);
+}
+
 /**
  * The display opener alone on the line at `from` (up to 3 leading spaces,
  * trailing spaces or tabs; the source's last line may be unterminated), or

package/src/prompt.ts

@@ -1,3 +1,4 @@
+import { LRUCache } from "./lru";
 import type { HelperDelegate, Template } from "./template";
 import * as Handlebars from "./template";
 
@@ -526,7 +527,8 @@ export function registerPartial(name: string, fn: Template): void {
 	handlebars.registerPartial(name, fn);
 }
 
-const compiledTemplateCache = new Map<string, (context: TemplateContext) => string>();
+// Bounded: some callers compile template text that already embeds user arguments.
+const compiledTemplateCache = new LRUCache<string, (context: TemplateContext) => string>({ max: 256 });
 
 export function compile(template: string): (context: TemplateContext) => string {
 	// Keyed on the raw template so repeat renders skip parsing.

package/src/ptree.ts

@@ -183,10 +183,12 @@ export class ChildProcess<In extends InMask = InMask> {
 	#stderrDone: Promise<void>;
 	#exited: Promise<number>;
 	#openPipeReaders = 1;
-	// Pipe reads race this cutoff only when attachTimeout() configures a
-	// command deadline. Untimed commands preserve complete EOF-based capture.
-	#drainCutoff: Promise<void>;
-	#resolveDrainCutoff: () => void;
+	// Set by attachTimeout() at the command deadline; untimed commands keep
+	// complete EOF-based capture. Active pipe readers are cancelled at cutoff so
+	// their pending read() settles as done and partial output is kept.
+	#cutoff = false;
+	/** Readers of piped stdio; the timeout cancels them so pending reads settle. */
+	#pipeReaders = new Set<{ cancel(reason?: unknown): Promise<void> }>();
 	#timeoutTimer?: NodeJS.Timeout;
 	#stderrStream?: ReadableStream<Uint8Array>;
 	// Termination in flight after kill(); aborted exits await it before reporting.
@@ -224,31 +226,24 @@ export class ChildProcess<In extends InMask = InMask> {
 		// Normalize Bun's exited promise into our exitReason / exitedCleanly model.
 		const { promise, resolve, reject } = Promise.withResolvers<number>();
 		this.#exited = promise;
-		const drainCutoff = Promise.withResolvers<void>();
-		this.#drainCutoff = drainCutoff.promise;
-		this.#resolveDrainCutoff = drainCutoff.resolve;
-		// The cutoff remains pending for untimed commands, preserving complete
-		// EOF-based capture. attachTimeout() resolves it at the command deadline.
 
-		const pipeCutoff = this.#drainCutoff;
 		this.#stderrDone = (async () => {
 			const reader = stderrStream.getReader();
+			this.#pipeReaders.add(reader);
 			try {
 				for (;;) {
-					const chunk = await Promise.race([
-						reader.read().then(r => ({ cutoff: false as const, r })),
-						pipeCutoff.then(() => ({ cutoff: true as const })),
-					]);
-					if (chunk.cutoff) {
+					if (this.#cutoff) {
 						await reader.cancel().catch(() => {});
 						break;
 					}
-					if (chunk.r.done) break;
-					this.#stderrChunks?.push(chunk.r.value);
-					this.#stderrTail += dec.decode(chunk.r.value, { stream: true });
+					const r = await reader.read();
+					if (r.done) break;
+					this.#stderrChunks?.push(r.value);
+					this.#stderrTail += dec.decode(r.value, { stream: true });
 					trim();
 				}
 			} catch {}
+			this.#pipeReaders.delete(reader);
 			this.#openPipeReaders--;
 			this.#stderrTail += dec.decode();
 			trim();
@@ -440,24 +435,23 @@ export class ChildProcess<In extends InMask = InMask> {
 	async #readStream(stream: ReadableStream<Uint8Array>): Promise<string> {
 		this.#openPipeReaders++;
 		const reader = stream.getReader();
+		this.#pipeReaders.add(reader);
 		const dec = new TextDecoder();
 		let out = "";
 		try {
 			for (;;) {
-				const chunk = await Promise.race([
-					reader.read().then(r => ({ cutoff: false as const, r })),
-					this.#drainCutoff.then(() => ({ cutoff: true as const })),
-				]);
-				if (chunk.cutoff) {
+				if (this.#cutoff) {
 					await reader.cancel().catch(() => {});
 					break;
 				}
-				if (chunk.r.done) break;
-				out += dec.decode(chunk.r.value, { stream: true });
+				const r = await reader.read();
+				if (r.done) break;
+				out += dec.decode(r.value, { stream: true });
 			}
 		} catch {
 			// A cancelled or failed read keeps whatever was already collected.
 		}
+		this.#pipeReaders.delete(reader);
 		this.#openPipeReaders--;
 		return out + dec.decode();
 	}
@@ -465,29 +459,27 @@ export class ChildProcess<In extends InMask = InMask> {
 	async #readBytes(): Promise<Uint8Array<ArrayBuffer>> {
 		const reader = this.proc.stdout.getReader();
 		this.#openPipeReaders++;
+		this.#pipeReaders.add(reader);
 		const chunks: Uint8Array[] = [];
 		let length = 0;
 		try {
 			for (;;) {
-				const chunk = await Promise.race([
-					reader.read().then(r => ({ cutoff: false as const, r })),
-					this.#drainCutoff.then(() => ({ cutoff: true as const })),
-				]);
-				if (chunk.cutoff) {
+				if (this.#cutoff) {
 					await reader.cancel().catch(() => {});
 					break;
 				}
-				if (chunk.r.done) break;
-				chunks.push(chunk.r.value);
-				length += chunk.r.value.byteLength;
+				const r = await reader.read();
+				if (r.done) break;
+				chunks.push(r.value);
+				length += r.value.byteLength;
 			}
 		} catch {
 			// A cancelled or failed read keeps whatever was already collected.
 		} finally {
+			this.#pipeReaders.delete(reader);
 			this.#openPipeReaders--;
 			reader.releaseLock();
 		}
-
 		const bytes = new Uint8Array(length);
 		let offset = 0;
 		for (const chunk of chunks) {
@@ -597,7 +589,8 @@ export class ChildProcess<In extends InMask = InMask> {
 			) {
 				this.kill(new TimeoutError(ms, this.#stderrTail), -1);
 			}
-			this.#resolveDrainCutoff();
+			this.#cutoff = true;
+			for (const reader of this.#pipeReaders) reader.cancel().catch(() => {});
 		}, ms);
 		timer.unref?.();
 		this.#timeoutTimer = timer;