@linxiraos/pi-utils 1.1.26 → 1.2.0

package/src/math-delimiters.ts

@@ -8,6 +8,9 @@
 /** Opening delimiter. Each closer (`$`, `$$`, `\)`, `\]`) is as wide as its opener. */
 export type MathOpener = "$" | "$$" | "\\(" | "\\[";
 
+/** Opener of an own-line display block. */
+export type MathBlockOpener = "$$" | "\\[";
+
 /** A closed math span found in the source. */
 export interface MathSpan {
 	opener: MathOpener;
@@ -33,8 +36,8 @@ export interface MathBlock {
 // it. The own-line requirement leaves inline `$$…$$` inside prose to the span
 // grammar below. `\r?\n` at each line boundary keeps the grammar CRLF-safe for
 // direct callers; marked-fed renderers already normalize line endings first.
-const MATH_BLOCK_DOLLAR = /^ {0,3}\$\$[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\$\$[ \t]*(?:\r?\n|$)/;
-const MATH_BLOCK_BRACKET = /^ {0,3}\\\[[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\\\][ \t]*(?:\r?\n|$)/;
+const MATH_BLOCK_DOLLAR = / {0,3}\$\$[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\$\$[ \t]*(?:\r?\n|$)/y;
+const MATH_BLOCK_BRACKET = / {0,3}\\\[[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\\\][ \t]*(?:\r?\n|$)/y;
 
 /**
  * Leftmost offset at or after `from` where an opener could begin. A scan hint,
@@ -182,9 +185,126 @@ function spanOf(source: string, opener: MathOpener, bodyStart: number, closeAt:
 
 /** The own-line display block starting at offset 0, or `undefined`. */
 export function mathBlockAt(source: string): MathBlock | undefined {
-	const match = MATH_BLOCK_DOLLAR.exec(source) ?? MATH_BLOCK_BRACKET.exec(source);
-	if (!match || match[1].trim() === "") return undefined;
-	return { raw: match[0], body: match[1] };
+	MATH_BLOCK_DOLLAR.lastIndex = 0;
+	MATH_BLOCK_BRACKET.lastIndex = 0;
+	return blockOf(MATH_BLOCK_DOLLAR.exec(source) ?? MATH_BLOCK_BRACKET.exec(source));
+}
+
+/** The block a match of the block grammar describes; a whitespace-only body is no block. */
+function blockOf(match: RegExpExecArray | null): MathBlock | undefined {
+	return match === null || match[1].trim() === "" ? undefined : { raw: match[0], body: match[1] };
+}
+
+// An own-line display opener line (`$$` or `\[` after up to 3 spaces), capturing
+// the opener and the line's end: "" when it is the source's unterminated last line.
+const MATH_BLOCK_OPENER_LINE_RE = / {0,3}(\$\$|\\\[)[ \t]*(\r?\n|$)/y;
+
+/**
+ * {@link mathBlockAt} for many offsets of one `source`. An own-line opener
+ * whose closer line is missing means every later opener of the same kind
+ * misses one too, since its search covers a suffix of that search. The scan
+ * keeps that answer, so asking at every block start takes linear time instead
+ * of a scan to the end of `source` per unclosed opener.
+ */
+export class MathBlockScan {
+	readonly #source: string;
+	// Offset of the first `$$` / `\[` opener line found with no closer line after it.
+	#unclosedDollarFrom = Number.POSITIVE_INFINITY;
+	#unclosedBracketFrom = Number.POSITIVE_INFINITY;
+
+	constructor(source: string) {
+		this.#source = source;
+	}
+
+	/** The own-line display block starting at `from`, or `undefined`. */
+	at(from: number): MathBlock | undefined {
+		MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+		const line = MATH_BLOCK_OPENER_LINE_RE.exec(this.#source);
+		// An unterminated opener line opens no block.
+		if (line === null || line[2] === "") return undefined;
+		const dollar = line[1] === "$$";
+		if (from >= (dollar ? this.#unclosedDollarFrom : this.#unclosedBracketFrom)) return undefined;
+		const grammar = dollar ? MATH_BLOCK_DOLLAR : MATH_BLOCK_BRACKET;
+		grammar.lastIndex = from;
+		const match = grammar.exec(this.#source);
+		if (match === null) {
+			if (dollar) this.#unclosedDollarFrom = from;
+			else this.#unclosedBracketFrom = from;
+		}
+		return blockOf(match);
+	}
+}
+
+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
+ * `undefined`.
+ */
+export function mathBlockOpenerAt(source: string, from = 0): MathBlockOpener | undefined {
+	MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+	const line = MATH_BLOCK_OPENER_LINE_RE.exec(source);
+	return line === null ? undefined : line[1] === "$$" ? "$$" : "\\[";
+}
+
+/**
+ * Whether the own-line display block opened at `from` in `source` is closed,
+ * or could still close once more text is appended: the text from `from`
+ * onward is a streaming prefix whose real closer may not have arrived. A
+ * closer on the unterminated last line has not arrived either, since the next
+ * append may extend it into text (`$$ E = mc^2 $$`). With no opener line at
+ * `from` it returns false before scanning, so a caller can ask at every block
+ * start.
+ */
+export function mathBlockMayCloseAt(source: string, from = 0): boolean {
+	MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+	const line = MATH_BLOCK_OPENER_LINE_RE.exec(source);
+	if (line === null) return false;
+	// The opener's own line is still being written.
+	if (line[2] === "") return true;
+	const grammar = line[1] === "$$" ? MATH_BLOCK_DOLLAR : MATH_BLOCK_BRACKET;
+	grammar.lastIndex = from;
+	const match = grammar.exec(source);
+	// No closer line yet, or only on the last line, which is still being written.
+	if (match === null || (from + match[0].length === source.length && !match[0].endsWith("\n"))) return true;
+	return blockOf(match) !== undefined;
+}
+
+// A display closer alone on its line, captured; the last line counts unterminated.
+const MATH_BLOCK_CLOSER_LINE_RE = /(?<=^|\n) {0,3}(\$\$|\\\])[ \t]*(?=\r?\n|$)/g;
+
+/**
+ * Offset of the first line of `source`, from the line start `from` on, that
+ * holds the closer of `opener` alone (up to 3 leading spaces, trailing spaces
+ * or tabs), the unterminated last line included, or `undefined`: the first
+ * line at which a block `opener` opened before `from` could close.
+ */
+export function mathBlockCloserIndex(source: string, from: number, opener: MathBlockOpener): number | undefined {
+	const closer = opener === "$$" ? "$$" : "\\]";
+	MATH_BLOCK_CLOSER_LINE_RE.lastIndex = from;
+	for (
+		let line = MATH_BLOCK_CLOSER_LINE_RE.exec(source);
+		line !== null;
+		line = MATH_BLOCK_CLOSER_LINE_RE.exec(source)
+	) {
+		if (line[1] === closer) return line.index;
+	}
+	return undefined;
 }
 
 /**

package/src/module-timer.ts

@@ -37,7 +37,7 @@
  * **Coverage limits:**
  * - TS/TSX only — intercepting `node_modules` CJS `.js`/`.cjs` and forcing ESM
  *   breaks their default-export detection, so they are left to Bun's default path.
- * - **Dev runs only.** In the compiled `omp` binary every module is pre-bundled
+ * - **Dev runs only.** In the compiled `zetacode` binary every module is pre-bundled
  *   into bunfs, so `onLoad` never fires; profile with a `bun --preload` dev run.
  */
 import { readFileSync } from "node:fs";
@@ -51,19 +51,19 @@ import { moduleLoadBuffer } from "./timing-buffer";
 // timing lives) is uniformly TypeScript, so a TS-only filter is both safe and
 // sufficient. Declaration files are imported as text assets, never evaluated.
 const MODULE_LOADER_FILTER = /^(?!.*\.d\.[mc]?ts$).*\.[mc]?tsx?$/;
-const MODULE_COMPLETE_KEY: symbol = Symbol.for("omp.moduleLoadComplete");
-const MODULE_BODY_START_KEY: symbol = Symbol.for("omp.moduleBodyStart");
+const MODULE_COMPLETE_KEY: symbol = Symbol.for("zeta.moduleLoadComplete");
+const MODULE_BODY_START_KEY: symbol = Symbol.for("zeta.moduleBodyStart");
 const STATIC_IMPORT_PATTERN =
 	/\b(?:import|export)\s+(?:type\s+)?(?:[^"']*?\s+from\s+)?["']([^"']+)["']|\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
 
 type CompleteStore = Record<symbol, ((path: string) => void) | undefined>;
 
 function bodyStartMarker(path: string): string {
-	return `;globalThis[Symbol.for("omp.moduleBodyStart")]?.(${JSON.stringify(path)});\n`;
+	return `;globalThis[Symbol.for("zeta.moduleBodyStart")]?.(${JSON.stringify(path)});\n`;
 }
 
 function completionMarker(path: string): string {
-	return `\n;globalThis[Symbol.for("omp.moduleLoadComplete")]?.(${JSON.stringify(path)});\n`;
+	return `\n;globalThis[Symbol.for("zeta.moduleLoadComplete")]?.(${JSON.stringify(path)});\n`;
 }
 
 function instrumentContents(path: string, contents: string): string {

package/src/postmortem.ts

@@ -332,7 +332,7 @@ function faultWorkerIpcChannels(err: Error): void {
 /**
  * Graceful shutdown driven by `process.stdout`'s own `error` event.
  *
- * A closed stdout consumer (`zeta-c --help | head`, an ACP client dropping the
+ * A closed stdout consumer (`zetacode --help | head`, an ACP client dropping the
  * pipe) delivers the broken-pipe write here — attributable to stdout by
  * construction, unlike a process-wide `syscall: "write"` match that a closed
  * subprocess stdin or socket would also satisfy — so it runs cleanup and exits

package/src/process-name.ts

@@ -1,6 +1,6 @@
 /**
- * Set the OS-visible process name (`/proc/self/comm`) so `omp` shows up as
- * `omp` — not `bun` — in `ps`, `pgrep`, `killall`, `top`, `htop`, and systemd.
+ * Set the OS-visible process name (`/proc/self/comm`) so `zetacode` shows up as
+ * `zetacode` — not `bun` — in `ps`, `pgrep`, `killall`, `top`, `htop`, and systemd.
  *
  * Bun's `process.title` setter only stores the value on the JS side; unlike
  * Node/libuv it never calls `prctl(PR_SET_NAME)`, so the kernel's `comm` stays

package/src/procmgr.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { Process, ProcessStatus } from "@linxiraos/pi-natives";
 import type { Subprocess } from "bun";
-import { getAgentDir, MAIN_CONFIG_FILENAMES } from "./dirs";
+import { getAgentDir, getProjectDir, MAIN_CONFIG_FILENAMES } from "./dirs";
 import { $env, filterChildShellEnv } from "./env";
 import { isExecutable } from "./executable";
 import { $which } from "./which";
@@ -20,18 +20,31 @@ export interface ShellConfigOptions {
 	/** File path or runtime layer that supplied the active shell setting. */
 	configSource?: string;
 }
-/** Auto-resolved shell (no custom path); stable for the process lifetime. */
+/** Auto-resolved shell (no custom path); kept until {@link refreshShellConfigCache}. */
 let cachedDefaultShellConfig: ShellConfig | null = null;
 /** Config for the most recent custom `shellPath`; never served once the path is cleared. */
 let cachedCustomShellConfig: ShellConfig | null = null;
+/**
+ * The child-shell environment {@link refreshShellConfigCache} last captured. Unset
+ * until the first refresh, so spawn environments are built from the live environment.
+ */
+let capturedChildShellEnv: Record<string, string> | undefined;
+/**
+ * Project whose dotenv values the spawn environment filters out: the one current
+ * when it was first built or captured.
+ * That is normally the launch project, whose dotenv files Bun and omp load into
+ * `process.env`; a later session in another project must not receive them.
+ */
+let spawnEnvProjectDir: string | undefined;
 
 /**
  * Build the spawn environment (cached).
  */
 function buildSpawnEnv(shell: string): Record<string, string> {
 	const noCI = $env.PI_BASH_NO_CI || $env.CLAUDE_BASH_NO_CI;
+	spawnEnvProjectDir ??= getProjectDir();
 	return {
-		...filterChildShellEnv(Bun.env),
+		...(capturedChildShellEnv ?? filterChildShellEnv(Bun.env, spawnEnvProjectDir)),
 		SHELL: shell,
 		GIT_EDITOR: "true",
 		GPG_TTY: "not a tty",
@@ -145,6 +158,17 @@ export function resolveBasicShell(): string | undefined {
  *
  * Exported for tests; `env` overrides Bun.env-based discovery.
  */
+
+/** True for the WSL launcher bash.exe variants, which are not Windows shells. */
+function isWslLauncher(bashPath: string): boolean {
+	const normalized = bashPath.toLowerCase().replaceAll("/", "\\");
+	return (
+		normalized.endsWith("\\system32\\bash.exe") ||
+		normalized.endsWith("\\windowsapps\\bash.exe") ||
+		normalized.endsWith("\\system32\\wsl.exe")
+	);
+}
+
 export function resolveWindowsShell(env: Record<string, string | undefined> = Bun.env): string {
 	const gitRoots = [
 		env.ProgramFiles && path.join(env.ProgramFiles, "Git"),
@@ -160,8 +184,12 @@ export function resolveWindowsShell(env: Record<string, string | undefined> = Bu
 		if (fs.existsSync(candidate)) return candidate;
 	}
 
+	// The WSL launcher (`System32\bash.exe` / `WindowsApps\bash.exe`) is not a
+	// Windows shell: it runs inside Linux without the spawn environment, so
+	// scripted `-c` snapshots break. Skip it and let the sh.exe sibling (Git
+	// Bash) or cmd.exe win instead.
 	const bashOnPath = $which("bash.exe");
-	if (bashOnPath) return bashOnPath;
+	if (bashOnPath && !isWslLauncher(bashOnPath)) return bashOnPath;
 
 	const shOnPath = $which("sh.exe");
 	if (shOnPath) {
@@ -202,6 +230,32 @@ export function getShellConfig(customShellPath?: string, options: ShellConfigOpt
 	return cachedDefaultShellConfig;
 }
 
+/**
+ * Capture the current process environment for child shells and drop both cached
+ * shell configs, so the next {@link getShellConfig} builds the spawn environment
+ * from that capture. Call right after code that changed `process.env` in a way
+ * child shells must see, such as extension session lifecycle handlers exporting
+ * session-scoped variables; later writes reach child shells only at the next call.
+ */
+export function refreshShellConfigCache(): void {
+	spawnEnvProjectDir ??= getProjectDir();
+	capturedChildShellEnv = filterChildShellEnv(Bun.env, spawnEnvProjectDir);
+	cachedDefaultShellConfig = null;
+	cachedCustomShellConfig = null;
+}
+
+/**
+ * Test-only: forget the capture and both cached shell configs, so the next
+ * {@link getShellConfig} builds from the live environment again. Production code
+ * MUST NOT call this; the capture's lifecycle is owned by {@link refreshShellConfigCache}.
+ */
+export function __resetShellConfigCacheForTests(): void {
+	capturedChildShellEnv = undefined;
+	spawnEnvProjectDir = undefined;
+	cachedDefaultShellConfig = null;
+	cachedCustomShellConfig = null;
+}
+
 /** Platform shell discovery used when no custom `shellPath` is configured. */
 function resolveDefaultShell(): string {
 	if (process.platform === "win32") {

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;