@oh-my-pi/pi-utils 15.10.10 → 15.10.11

package/dist/types/dirs.d.ts

@@ -117,6 +117,8 @@ export declare function getAutoresearchDbPath(encodedProject: string): string;
 export declare function getAutoresearchRunDir(encodedProject: string, runId: number): string;
 /** Get the path to agent.db (SQLite database for settings and auth storage). */
 export declare function getAgentDbPath(agentDir?: string): string;
+/** Get the last-seen-changelog-version marker file (~/.omp/agent/last-changelog-version). */
+export declare function getLastChangelogVersionPath(agentDir?: string): string;
 /** Get the path to history.db (SQLite database for session history). */
 export declare function getHistoryDbPath(agentDir?: string): string;
 /** Get the path to models.db (model cache database). */

package/dist/types/env.d.ts

@@ -52,4 +52,8 @@ export declare function isBunTestRuntime(): boolean;
  * first for cheap fast-path detection.
  */
 export declare function isCompiledBinary(): boolean;
+/** Called by CLI entrypoints whose main module dispatches worker argv selectors. */
+export declare function declareWorkerHostEntry(): void;
+/** Main-module path of the self-dispatching CLI host, or null outside it. */
+export declare function workerHostEntry(): string | null;
 export declare function $flag(name: string, def?: boolean): boolean;

package/dist/types/logger.d.ts

@@ -31,6 +31,15 @@ export declare function info(message: string, context?: Record<string, unknown>)
  * @param context - The context to log.
  */
 export declare function debug(message: string, context?: Record<string, unknown>): void;
+/**
+ * Streaming startup markers, enabled by `PI_DEBUG_STARTUP`. Unlike the
+ * PI_TIMING tree (printed only after startup completes), these write one
+ * synchronous stderr line as each phase begins/ends, so a hard hang still
+ * shows the last phase that started. `fs.writeSync(2)` is used deliberately:
+ * it cannot be reordered or buffered past a synchronous block of the event
+ * loop (dlopen, sync fs on a dead mount, spawnSync).
+ */
+export declare function startupMarker(text: string): void;
 export declare function timingModeIncludes(option: "full" | "x"): boolean;
 export declare function shouldExitAfterTimings(): boolean;
 /**
@@ -55,6 +64,12 @@ export declare function recordModuleLoadSpan(path: string, start: number, durati
  * End timing window and clear buffers.
  */
 export declare function endTiming(): void;
+/**
+ * Ops of the currently-open span chain (root → deepest), following the most
+ * recently started unfinished child at each level. Lets a startup watchdog
+ * name the phase a stalled startup is stuck in.
+ */
+export declare function openSpanPath(): string[];
 /**
  * Time a span. Three forms:
  *   time(op)                    — point event (zero-duration breadcrumb)

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "15.10.10",
+	"version": "15.10.11",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -31,7 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "15.10.10",
+		"@oh-my-pi/pi-natives": "15.10.11",
 		"beautiful-mermaid": "^1.1.3",
 		"handlebars": "^4.7.9",
 		"winston": "^3.19.0",

package/src/cli.ts

@@ -9,8 +9,25 @@
  *   - Lazy command imports (only the invoked command is loaded)
  *   - Typed `this.parse()` output matching oclif's API shape
  */
+import * as fs from "node:fs";
 import { parseArgs as nodeParseArgs } from "node:util";
 
+/**
+ * Streaming startup marker, enabled by `PI_DEBUG_STARTUP`. Local copy of
+ * `logger.startupMarker` so the minimal `--version`/bootstrap import graph
+ * stays free of the winston-backed logger module. Synchronous on purpose:
+ * a command module whose import hangs (dlopen, fs on a dead mount) must
+ * still leave its `:start` marker behind.
+ */
+function startupMarker(text: string): void {
+	if (!process.env.PI_DEBUG_STARTUP) return;
+	try {
+		fs.writeSync(2, `[startup] ${text}\n`);
+	} catch {
+		// stderr unavailable; markers are best-effort
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Flag & Arg descriptors
 // ---------------------------------------------------------------------------
@@ -392,14 +409,14 @@ export async function run(opts: RunOptions): Promise<void> {
 		return;
 	}
 
-	// Per-command help
+	// Per-command help: load only the requested command. Loading the full
+	// command table here would make `omp <cmd> --help` hang or crash whenever
+	// any *unrelated* command module misbehaves at import time.
 	if (commandArgv.includes("--help") || commandArgv.includes("-h")) {
-		const config = await loadAllCommands(opts);
-		// Resolve aliases for help too
 		const entry = findEntry(opts.commands, commandId);
-		const Cmd = entry ? config.commands.get(entry.name) : undefined;
-		if (Cmd) {
-			renderCommandHelp(bin, entry!.name, Cmd);
+		if (entry) {
+			const Cmd = await loadEntry(entry);
+			renderCommandHelp(bin, entry.name, Cmd);
 		} else {
 			process.stderr.write(`Unknown command: ${commandId}\n`);
 		}
@@ -415,16 +432,24 @@ export async function run(opts: RunOptions): Promise<void> {
 		return;
 	}
 
-	const Cmd = await entry.load();
+	const Cmd = await loadEntry(entry);
 	const config: CliConfig = { bin, version, commands: new Map([[entry.name, Cmd]]) };
 	const instance = new Cmd(commandArgv, config);
 	await instance.run();
 }
 
+/** Load one command module, leaving streaming markers around the import. */
+async function loadEntry(entry: CommandEntry): Promise<CommandCtor> {
+	startupMarker(`cli:load:${entry.name}:start`);
+	const Cmd = await entry.load();
+	startupMarker(`cli:load:${entry.name}:done`);
+	return Cmd;
+}
+
 /** Resolve all command loaders for help/alias display. */
 async function loadAllCommands(opts: RunOptions): Promise<CliConfig> {
 	const commands = new Map<string, CommandCtor>();
-	const loaded = await Promise.all(opts.commands.map(async e => [e.name, await e.load()] as const));
+	const loaded = await Promise.all(opts.commands.map(async e => [e.name, await loadEntry(e)] as const));
 	for (const [name, Cmd] of loaded) {
 		commands.set(name, Cmd);
 	}

package/src/dirs.ts

@@ -398,6 +398,11 @@ export function getAgentDbPath(agentDir?: string): string {
 	return dirs.agentSubdir(agentDir, "agent.db", "data");
 }
 
+/** Get the last-seen-changelog-version marker file (~/.omp/agent/last-changelog-version). */
+export function getLastChangelogVersionPath(agentDir?: string): string {
+	return dirs.agentSubdir(agentDir, "last-changelog-version", "state");
+}
+
 /** Get the path to history.db (SQLite database for session history). */
 export function getHistoryDbPath(agentDir?: string): string {
 	return dirs.agentSubdir(agentDir, "history.db", "data");

package/src/env.ts

@@ -156,11 +156,31 @@ export function isBunTestRuntime(): boolean {
  * first for cheap fast-path detection.
  */
 export function isCompiledBinary(): boolean {
-	if (Bun.env.PI_COMPILED) return true;
+	if (process.env.PI_COMPILED || Bun.env.PI_COMPILED) return true;
 	const url = import.meta.url;
 	return url.includes("$bunfs") || url.includes("~BUN") || url.includes("%7EBUN");
 }
 
+/**
+ * Main-module path declared by self-dispatching CLI entrypoints — entries
+ * whose top-level argv handling routes hidden `__omp_*` worker selectors.
+ * Worker spawn sites re-enter this module via `new Worker(entry, { argv })`,
+ * so every distribution (source, npm bundle, compiled binary) needs exactly
+ * one JavaScript entrypoint. Never set under `bun test`, SDK embedding, or
+ * standalone package bins — those hosts load worker modules directly.
+ */
+let workerHostMain: string | null = null;
+
+/** Called by CLI entrypoints whose main module dispatches worker argv selectors. */
+export function declareWorkerHostEntry(): void {
+	workerHostMain = Bun.main;
+}
+
+/** Main-module path of the self-dispatching CLI host, or null outside it. */
+export function workerHostEntry(): string | null {
+	return workerHostMain;
+}
+
 const TRUTHY: Dict<boolean> = {
 	"1": true,
 	Y: true,

package/src/logger.ts

@@ -47,25 +47,30 @@ function jsonReplacer(_key: string, value: unknown): unknown {
 	return value;
 }
 
-/** Custom format that includes pid and flattens metadata */
-const logFormat = winston.format.combine(
-	winston.format.timestamp({ format: "YYYY-MM-DDTHH:mm:ss.SSSZ" }),
-	winston.format.printf(({ timestamp, level, message, ...meta }) => {
-		const entry: Record<string, unknown> = {
-			timestamp,
-			level,
-			pid: process.pid,
-			message,
-		};
-		// Flatten metadata into entry
-		for (const [key, value] of Object.entries(meta)) {
-			if (key !== "level" && key !== "timestamp" && key !== "message") {
-				entry[key] = value;
+/** Custom format that includes pid and flattens metadata; built on first use. */
+let logFormat: winston.Logform.Format | undefined;
+
+function getLogFormat(): winston.Logform.Format {
+	logFormat ??= winston.format.combine(
+		winston.format.timestamp({ format: "YYYY-MM-DDTHH:mm:ss.SSSZ" }),
+		winston.format.printf(({ timestamp, level, message, ...meta }) => {
+			const entry: Record<string, unknown> = {
+				timestamp,
+				level,
+				pid: process.pid,
+				message,
+			};
+			// Flatten metadata into entry
+			for (const [key, value] of Object.entries(meta)) {
+				if (key !== "level" && key !== "timestamp" && key !== "message") {
+					entry[key] = value;
+				}
 			}
-		}
-		return JSON.stringify(entry, jsonReplacer);
-	}),
-);
+			return JSON.stringify(entry, jsonReplacer);
+		}),
+	);
+	return logFormat;
+}
 
 /** Build a rotating file transport, materializing the target directory lazily. */
 function makeFileTransport(dir?: string): winston.transport {
@@ -80,17 +85,35 @@ function makeFileTransport(dir?: string): winston.transport {
 }
 
 function makeConsoleTransport(): winston.transport {
-	return new winston.transports.Console({ format: logFormat });
+	return new winston.transports.Console({ format: getLogFormat() });
 }
 
-/** The winston logger instance. Default: file ON (TUI-safe), console OFF. */
-const winstonLogger = winston.createLogger({
-	level: "debug",
-	format: logFormat,
-	transports: [makeFileTransport()],
-	// Don't exit on error - logging failures shouldn't crash the app
-	exitOnError: false,
-});
+/**
+ * Desired transport configuration, applied when the winston logger is built.
+ * Default: file ON (TUI-safe), console OFF.
+ */
+let transportOpts: { console?: boolean; file?: boolean | string } = { file: true };
+
+/** The winston logger instance, created lazily on first log emission. */
+let winstonLogger: winston.Logger | undefined;
+
+function buildTransports(opts: { console?: boolean; file?: boolean | string }): winston.transport[] {
+	const transports: winston.transport[] = [];
+	if (opts.file) transports.push(makeFileTransport(typeof opts.file === "string" ? opts.file : undefined));
+	if (opts.console) transports.push(makeConsoleTransport());
+	return transports;
+}
+
+function getWinstonLogger(): winston.Logger {
+	winstonLogger ??= winston.createLogger({
+		level: "debug",
+		format: getLogFormat(),
+		transports: buildTransports(transportOpts),
+		// Don't exit on error - logging failures shouldn't crash the app
+		exitOnError: false,
+	});
+	return winstonLogger;
+}
 
 /**
  * Replace the active log transports. Pass `console: true, file: false` for
@@ -98,11 +121,10 @@ const winstonLogger = winston.createLogger({
  * logs piped into a process supervisor instead of the rotating file.
  */
 export function setTransports(opts: { console?: boolean; file?: boolean | string }): void {
+	transportOpts = opts;
+	if (!winstonLogger) return; // applied lazily when the logger is first built
 	winstonLogger.clear();
-	if (opts.file) {
-		winstonLogger.add(makeFileTransport(typeof opts.file === "string" ? opts.file : undefined));
-	}
-	if (opts.console) winstonLogger.add(makeConsoleTransport());
+	for (const transport of buildTransports(opts)) winstonLogger.add(transport);
 }
 
 /**
@@ -112,7 +134,7 @@ export function setTransports(opts: { console?: boolean; file?: boolean | string
  */
 export function error(message: string, context?: Record<string, unknown>): void {
 	try {
-		winstonLogger.error(message, context);
+		getWinstonLogger().error(message, context);
 	} catch {
 		// Silently ignore logging failures
 	}
@@ -125,7 +147,7 @@ export function error(message: string, context?: Record<string, unknown>): void
  */
 export function warn(message: string, context?: Record<string, unknown>): void {
 	try {
-		winstonLogger.warn(message, context);
+		getWinstonLogger().warn(message, context);
 	} catch {
 		// Silently ignore logging failures
 	}
@@ -138,7 +160,7 @@ export function warn(message: string, context?: Record<string, unknown>): void {
  */
 export function info(message: string, context?: Record<string, unknown>): void {
 	try {
-		winstonLogger.info(message, context);
+		getWinstonLogger().info(message, context);
 	} catch {
 		// Silently ignore logging failures
 	}
@@ -151,12 +173,29 @@ export function info(message: string, context?: Record<string, unknown>): void {
  */
 export function debug(message: string, context?: Record<string, unknown>): void {
 	try {
-		winstonLogger.debug(message, context);
+		getWinstonLogger().debug(message, context);
 	} catch {
 		// Silently ignore logging failures
 	}
 }
 
+/**
+ * Streaming startup markers, enabled by `PI_DEBUG_STARTUP`. Unlike the
+ * PI_TIMING tree (printed only after startup completes), these write one
+ * synchronous stderr line as each phase begins/ends, so a hard hang still
+ * shows the last phase that started. `fs.writeSync(2)` is used deliberately:
+ * it cannot be reordered or buffered past a synchronous block of the event
+ * loop (dlopen, sync fs on a dead mount, spawnSync).
+ */
+export function startupMarker(text: string): void {
+	if (!process.env.PI_DEBUG_STARTUP) return;
+	try {
+		fs.writeSync(2, `[startup] ${text}\n`);
+	} catch {
+		// stderr unavailable; markers are best-effort
+	}
+}
+
 const LOGGED_TIMING_THRESHOLD_MS = 0.5;
 
 interface Span {
@@ -329,6 +368,29 @@ export function endTiming(): void {
 	gRecordTimings = false;
 }
 
+/**
+ * Ops of the currently-open span chain (root → deepest), following the most
+ * recently started unfinished child at each level. Lets a startup watchdog
+ * name the phase a stalled startup is stuck in.
+ */
+export function openSpanPath(): string[] {
+	const ops: string[] = [];
+	let node = gRootSpan;
+	while (node) {
+		let next: Span | undefined;
+		for (let i = node.children.length - 1; i >= 0; i--) {
+			if (node.children[i].end === undefined) {
+				next = node.children[i];
+				break;
+			}
+		}
+		if (!next) break;
+		ops.push(next.op);
+		node = next;
+	}
+	return ops;
+}
+
 function durationOf(span: Span): number {
 	if (span.point || span.end === undefined) return 0;
 	return span.end - span.start;
@@ -550,33 +612,51 @@ function isParallel(span: Span): boolean {
 export function time(op: string): void;
 export function time<T, A extends unknown[]>(op: string, fn: (...args: A) => T, ...args: A): T;
 export function time<T, A extends unknown[]>(op: string, fn?: (...args: A) => T, ...args: A): T | undefined {
-	if (!gRecordTimings || !gRootSpan) {
-		if (fn === undefined) return undefined as T;
-		return fn(...args);
-	}
-
-	const parent = spanStorage.getStore() ?? gRootSpan;
-	const span: Span = { op, start: performance.now(), parent, children: [] };
-	parent.children.push(span);
+	const recording = gRecordTimings && gRootSpan !== undefined;
 
 	if (fn === undefined) {
-		span.end = span.start;
-		span.point = true;
+		startupMarker(op);
+		if (!recording) return undefined as T;
+		const parent = spanStorage.getStore() ?? gRootSpan!;
+		const now = performance.now();
+		parent.children.push({ op, start: now, end: now, parent, children: [], point: true });
 		return undefined as T;
 	}
 
-	const finish = (): void => {
-		span.end = performance.now();
+	if (!recording && !process.env.PI_DEBUG_STARTUP) {
+		return fn(...args);
+	}
+
+	startupMarker(`${op}:start`);
+	let span: Span | undefined;
+	if (recording) {
+		const parent = spanStorage.getStore() ?? gRootSpan!;
+		span = { op, start: performance.now(), parent, children: [] };
+		parent.children.push(span);
+	}
+
+	const finish = (ok: boolean): void => {
+		if (span) span.end = performance.now();
+		startupMarker(ok ? `${op}:done` : `${op}:fail`);
 	};
 	try {
-		const result = spanStorage.run(span, () => fn(...args));
+		const result = span ? spanStorage.run(span, () => fn(...args)) : fn(...args);
 		if (isPromise(result)) {
-			return result.finally(finish) as T;
+			return result.then(
+				value => {
+					finish(true);
+					return value;
+				},
+				error => {
+					finish(false);
+					throw error;
+				},
+			) as T;
 		}
-		finish();
+		finish(true);
 		return result;
 	} catch (error) {
-		finish();
+		finish(false);
 		throw error;
 	}
 }

package/src/prompt.ts

@@ -13,14 +13,53 @@ export interface PromptFormatOptions {
 
 // Opening XML tag (not self-closing, not closing)
 const OPENING_XML = /^<([a-z_-]+)(?:\s+[^>]*)?>$/;
-// Closing XML tag
-const CLOSING_XML = /^<\/([a-z_-]+)>$/;
-// Handlebars block end: {{/if}}, {{/has}}, {{/list}}, etc.
-const CLOSING_HBS = /^\{\{\//;
+
+/**
+ * Closing XML tag matcher, manual equivalent of `/^<\/([a-z_-]+)>$/` — avoids a
+ * RegExp exec (and match array allocation) per `<`-prefixed line. Caller
+ * guarantees `s` starts `</`.
+ */
+function closingTagName(s: string): string | null {
+	const n = s.length;
+	if (n < 4 || s.charCodeAt(n - 1) !== 62 /* > */) return null;
+	for (let j = 2; j < n - 1; j++) {
+		const c = s.charCodeAt(j);
+		if (!((c >= 97 /* a */ && c <= 122) /* z */ || c === 45 /* - */ || c === 95) /* _ */) return null;
+	}
+	return s.slice(2, n - 1);
+}
+
+/**
+ * Manual equivalent of {@link OPENING_XML}. Caller guarantees `s` starts with
+ * `<` but not `</`. Falls back to the regex when the char after the tag name
+ * is non-ASCII (possible unicode whitespace).
+ */
+function openingTagName(s: string): string | null {
+	const n = s.length;
+	if (n < 3 || s.charCodeAt(n - 1) !== 62 /* > */) return null;
+	let j = 1;
+	while (j < n - 1) {
+		const c = s.charCodeAt(j);
+		if ((c >= 97 /* a */ && c <= 122) /* z */ || c === 45 /* - */ || c === 95 /* _ */) j++;
+		else break;
+	}
+	if (j === 1) return null;
+	if (j === n - 1) return s.slice(1, j); // `<tag>`
+	const c = s.charCodeAt(j);
+	if (c !== 32 /* space */ && c !== 9 /* tab */) {
+		if (c < 128) return null;
+		const match = OPENING_XML.exec(s);
+		return match ? match[1] : null;
+	}
+	// `\s+[^>]*>$` ⇔ no further `>` before the final char.
+	return s.indexOf(">", j + 1) === n - 1 ? s.slice(1, j) : null;
+}
 // Table row
 const TABLE_ROW = /^\|.*\|$/;
 // Table separator (|---|---|)
 const TABLE_SEP = /^\|[-:\s|]+\|$/;
+// Any non-whitespace char — blank-line check without allocating a trimmed copy
+const NON_BLANK = /\S/;
 
 /**
  * RFC 2119 keywords (plus project aliases NEVER/AVOID) wrapped in markdown bold
@@ -28,6 +67,19 @@ const TABLE_SEP = /^\|[-:\s|]+\|$/;
  */
 const RFC2119_BOLD = /\*\*(MUST NOT|SHOULD NOT|RECOMMENDED|REQUIRED|OPTIONAL|SHOULD|MUST|MAY|NEVER|AVOID)\*\*/g;
 
+/**
+ * Fast pre-check for {@link normalizeRfc2119}: a line that lacks every one of
+ * these substrings is untouched by all three replacements, so the
+ * split/replace/join machinery can be skipped entirely.
+ */
+const RFC2119_GUARD = /\*\*(?:MUST|SHOULD|RECOMMENDED|REQUIRED|OPTIONAL|MAY|NEVER|AVOID)|MUST NOT|SHOULD NOT/;
+const MUST_NOT = /\bMUST NOT\b/g;
+const SHOULD_NOT = /\bSHOULD NOT\b/g;
+
+function applyRfc2119(text: string): string {
+	return text.replace(RFC2119_BOLD, "$1").replace(MUST_NOT, "NEVER").replace(SHOULD_NOT, "AVOID");
+}
+
 /**
  * Normalize RFC 2119 markers per project convention:
  *   - Strip `**KEYWORD**` bold (visual noise, no semantics).
@@ -35,12 +87,11 @@ const RFC2119_BOLD = /\*\*(MUST NOT|SHOULD NOT|RECOMMENDED|REQUIRED|OPTIONAL|SHO
  * Skips spans inside inline code (`` `…` ``) so alias definitions can be quoted literally.
  */
 function normalizeRfc2119(line: string): string {
+	if (!RFC2119_GUARD.test(line)) return line;
+	if (!line.includes("`")) return applyRfc2119(line);
 	const segments = line.split("`");
 	for (let i = 0; i < segments.length; i += 2) {
-		segments[i] = segments[i]
-			.replace(RFC2119_BOLD, "$1")
-			.replace(/\bMUST NOT\b/g, "NEVER")
-			.replace(/\bSHOULD NOT\b/g, "AVOID");
+		segments[i] = applyRfc2119(segments[i]);
 	}
 	return segments.join("`");
 }
@@ -73,19 +124,31 @@ type HtmlCommentState = {
 	inHtmlComment: boolean;
 };
 
+// Single-pass alternation equivalent to the former chain of seven .replace()
+// calls. Alternative order mirrors the old sequential order (`<->` before
+// `->`/`<-`), and every replacement emits a non-ASCII char, so one pass
+// produces byte-identical output to the sequential passes.
+const ASCII_SYMBOLS = /\.{3}|<->|->|<-|!=|<=|>=/g;
+const ASCII_SYMBOL_REPLACEMENTS: Record<string, string> = {
+	"...": "…",
+	"<->": "↔",
+	"->": "→",
+	"<-": "←",
+	"!=": "≠",
+	"<=": "≤",
+	">=": "≥",
+};
+const replaceAsciiSymbol = (match: string): string => ASCII_SYMBOL_REPLACEMENTS[match];
+
 function replaceCommonAsciiSymbols(line: string): string {
-	return line
-		.replace(/\.{3}/g, "…")
-		.replace(/<->/g, "↔")
-		.replace(/->/g, "→")
-		.replace(/<-/g, "←")
-		.replace(/!=/g, "≠")
-		.replace(/<=/g, "≤")
-		.replace(/>=/g, "≥");
+	return line.replace(ASCII_SYMBOLS, replaceAsciiSymbol);
 }
 
 function replaceCommonAsciiSymbolsOutsideHtmlComments(line: string, state: HtmlCommentState): string {
-	if (!state.inHtmlComment && !line.includes(HTML_COMMENT_OPEN) && !line.includes(HTML_COMMENT_CLOSE)) {
+	// When not inside a comment, a line without `<!--` takes the fast path even
+	// if it contains `-->`: the slow path would hit openIndex === -1 and replace
+	// the whole line identically.
+	if (!state.inHtmlComment && !line.includes(HTML_COMMENT_OPEN)) {
 		return replaceCommonAsciiSymbols(line);
 	}
 
@@ -133,86 +196,111 @@ export function format(content: string, options: PromptFormatOptions = {}): stri
 	} = options;
 	const isPreRender = renderPhase === "pre-render";
 	const lines = content.split("\n");
-	const result: string[] = [];
+	const result: string[] = new Array(lines.length);
+	let n = 0; // logical length of `result` (pops are n--)
 	let inCodeBlock = false;
 
 	const htmlCommentState: HtmlCommentState = { inHtmlComment: false };
 	const topLevelTags: string[] = [];
 
 	for (let i = 0; i < lines.length; i++) {
-		let line = lines[i].trimEnd();
-		let trimmedStart = line.trimStart();
-		if (trimmedStart.startsWith("```") || trimmedStart.startsWith("~~~")) {
+		const raw = lines[i];
+		// charCode fast paths: only pay for trimEnd when the last char might be
+		// whitespace (<= 0x20 ASCII ws/controls, >= 0x80 unicode ws). Untouched
+		// lines are pushed as the original string — no allocation.
+		const last = raw.charCodeAt(raw.length - 1);
+		let line = last <= 32 || last >= 128 ? raw.trimEnd() : raw;
+		// Locate the first non-whitespace char without allocating a trimStart
+		// copy; `s` is the indent width, `first` the char code there (NaN when
+		// the line is blank).
+		let s = 0;
+		let first = line.charCodeAt(0);
+		while (first === 32 /* space */ || first === 9 /* tab */) first = line.charCodeAt(++s);
+		if (first >= 128) {
+			// Possible unicode leading whitespace — defer to trimStart for exactness.
+			s = line.length - line.trimStart().length;
+			first = line.charCodeAt(s);
+		}
+
+		if ((first === 96 /* ` */ || first === 126) /* ~ */ && (line.startsWith("```", s) || line.startsWith("~~~", s))) {
 			inCodeBlock = !inCodeBlock;
-			result.push(line);
+			result[n++] = line;
 			continue;
 		}
 
 		if (inCodeBlock) {
-			result.push(line);
+			result[n++] = line;
 			continue;
 		}
 
 		if (replaceAsciiSymbols) {
-			line = replaceCommonAsciiSymbolsOutsideHtmlComments(line, htmlCommentState);
-		}
-		trimmedStart = line.trimStart();
-		const trimmed = line.trim();
-
-		const isOpeningXml = OPENING_XML.test(trimmedStart) && !trimmedStart.endsWith("/>");
-		if (isOpeningXml && line.length === trimmedStart.length) {
-			const match = OPENING_XML.exec(trimmedStart);
-			if (match) topLevelTags.push(match[1]);
+			const replaced = replaceCommonAsciiSymbolsOutsideHtmlComments(line, htmlCommentState);
+			if (replaced !== line) {
+				line = replaced;
+				s = 0;
+				first = line.charCodeAt(0);
+				while (first === 32 || first === 9) first = line.charCodeAt(++s);
+				if (first >= 128) {
+					s = line.length - line.trimStart().length;
+					first = line.charCodeAt(s);
+				}
+			}
 		}
 
-		const closingMatch = CLOSING_XML.exec(trimmedStart);
-		if (closingMatch) {
-			const tagName = closingMatch[1];
-			if (topLevelTags.length > 0 && topLevelTags[topLevelTags.length - 1] === tagName) {
-				topLevelTags.pop();
+		let isClosingLine = false;
+		if (first === 60 /* < */) {
+			const trimmedStart = s === 0 ? line : line.slice(s);
+			if (trimmedStart.charCodeAt(1) === 47 /* / */) {
+				const tagName = closingTagName(trimmedStart);
+				if (tagName !== null) {
+					isClosingLine = true;
+					if (topLevelTags.length > 0 && topLevelTags[topLevelTags.length - 1] === tagName) {
+						topLevelTags.pop();
+					}
+				}
+			} else if (s === 0 && !trimmedStart.endsWith("/>")) {
+				const tagName = openingTagName(trimmedStart);
+				if (tagName !== null) topLevelTags.push(tagName);
+			}
+		} else if (first === 124 /* | */) {
+			const trimmedStart = s === 0 ? line : line.slice(s);
+			if (TABLE_SEP.test(trimmedStart)) {
+				line = `${line.slice(0, s)}${compactTableSep(trimmedStart)}`;
+			} else if (TABLE_ROW.test(trimmedStart)) {
+				line = `${line.slice(0, s)}${compactTableRow(trimmedStart)}`;
 			}
-		} else if (isPreRender && trimmedStart.startsWith("{{")) {
-			/* keep indentation as-is in pre-render for Handlebars markers */
-		} else if (TABLE_SEP.test(trimmedStart)) {
-			const leadingWhitespace = line.slice(0, line.length - trimmedStart.length);
-			line = `${leadingWhitespace}${compactTableSep(trimmedStart)}`;
-		} else if (TABLE_ROW.test(trimmedStart)) {
-			const leadingWhitespace = line.slice(0, line.length - trimmedStart.length);
-			line = `${leadingWhitespace}${compactTableRow(trimmedStart)}`;
 		}
 
 		if (shouldNormalizeRfc2119) {
 			line = normalizeRfc2119(line);
 		}
 
-		if (trimmed === "") {
-			const nextLine = lines[i + 1]?.trim() ?? "";
+		if (s >= line.length) {
+			// Blank line (`line` carries no trailing whitespace, so it is "").
+			const next = lines[i + 1];
 			// Strip any run of 2+ consecutive blank lines entirely; preserve a single blank.
-			if (nextLine === "") {
-				while (result.length > 0 && result[result.length - 1].trim() === "") {
-					result.pop();
-				}
-				while (i + 1 < lines.length && lines[i + 1].trim() === "") i++;
+			if (next === undefined || next.length === 0 || !NON_BLANK.test(next)) {
+				while (n > 0 && result[n - 1].length === 0) n--;
+				let j = i + 1;
+				while (j < lines.length && (lines[j].length === 0 || !NON_BLANK.test(lines[j]))) j++;
+				i = j - 1;
 				continue;
 			}
-			const prevLine = result[result.length - 1]?.trim() ?? "";
-			if (prevLine === "") {
+			if (n === 0 || result[n - 1].length === 0) {
 				continue;
 			}
 		}
 
-		if (CLOSING_XML.test(trimmed) || (isPreRender && CLOSING_HBS.test(trimmed))) {
-			while (result.length > 0 && result[result.length - 1].trim() === "") {
-				result.pop();
-			}
+		// CLOSING_HBS (`/^\{\{\//`) ⇔ startsWith("{{/") at the indent offset.
+		if (isClosingLine || (isPreRender && first === 123 /* { */ && line.startsWith("{{/", s))) {
+			while (n > 0 && result[n - 1].length === 0) n--;
 		}
 
-		result.push(line);
+		result[n++] = line;
 	}
 
-	while (result.length > 0 && result[result.length - 1].trim() === "") {
-		result.pop();
-	}
+	while (n > 0 && result[n - 1].length === 0) n--;
+	result.length = n;
 
 	return result.join("\n");
 }
@@ -454,13 +542,14 @@ function disambiguateClosingBraces(template: string): string {
 const compiledTemplateCache = new Map<string, (context: TemplateContext) => string>();
 
 export function compile(template: string): (context: TemplateContext) => string {
-	const disambiguated = disambiguateClosingBraces(template);
-	const cached = compiledTemplateCache.get(disambiguated);
+	// Keyed on the raw template so repeat renders skip disambiguateClosingBraces
+	// (a full-template regex pass) as well as the Handlebars compile.
+	const cached = compiledTemplateCache.get(template);
 	if (cached) return cached;
-	const compiled = handlebars.compile(disambiguated, { noEscape: true, strict: false }) as (
+	const compiled = handlebars.compile(disambiguateClosingBraces(template), { noEscape: true, strict: false }) as (
 		context: TemplateContext,
 	) => string;
-	compiledTemplateCache.set(disambiguated, compiled);
+	compiledTemplateCache.set(template, compiled);
 	return compiled;
 }
 

package/src/snowflake.ts

@@ -1,6 +1,3 @@
-// 16-bit hex lookup table (65536 entries) for fast conversion
-const HEX4 = Array.from({ length: 65536 }, (_, i) => i.toString(16).padStart(4, "0"));
-
 function randu32() {
 	return crypto.getRandomValues(new Uint32Array(1))[0];
 }
@@ -28,29 +25,14 @@ namespace Snowflake {
 	//
 	export const MAX_SEQUENCE = MAX_SEQ;
 
-	// Parses a hex string or bigint to bigint.
-	//
-	function toBigInt(value: Snowflake): bigint {
-		const hi = Number.parseInt(value.substring(0, 8), 16);
-		const lo = Number.parseInt(value.substring(8, 16), 16);
-		return (BigInt(hi) << 32n) | BigInt(lo);
-	}
-
 	// Formats a sequence and timestamp into a snowflake hex string.
 	//
+	// dt fits well within BigInt range: (dt << 22) | seq stays under 2^64 for
+	// any dt < 2^42 (~year 2154), so a single 64-bit format is exact — and
+	// measures ~1.7x faster than stitching four 16-bit hex segments.
+	//
 	export function formatParts(dt: number, seq: number): Snowflake {
-		// Split dt into hi/lo to avoid exceeding Number.MAX_SAFE_INTEGER.
-		// dt is ~39 bits; dt<<22 would be ~61 bits, so we split at bit 10:
-		//   lo32 = (dtLo << 22) | seq   (10+22 = 32 bits, no overlap)
-		//   hi32 = dtHi                 (~29 bits)
-		const dtLo = dt % 1024;
-		const hi = (dt - dtLo) / 1024; // dt >>> 10
-		const lo = ((dtLo << 22) | seq) >>> 0;
-		const hi1 = (hi >>> 16) & 0xffff;
-		const hi2 = hi & 0xffff;
-		const lo1 = (lo >>> 16) & 0xffff;
-		const lo2 = lo & 0xffff;
-		return `${HEX4[hi1]}${HEX4[hi2]}${HEX4[lo1]}${HEX4[lo2]}` as Snowflake;
+		return ((BigInt(dt) << 22n) | BigInt(seq)).toString(16).padStart(16, "0") as Snowflake;
 	}
 
 	// Snowflake generator type.
@@ -85,8 +67,9 @@ namespace Snowflake {
 
 	// Gets the next snowflake given the timestamp.
 	//
-	const defaultSource = new Source();
+	let defaultSource: Source | undefined;
 	export function next(timestamp = Date.now()): Snowflake {
+		defaultSource ??= new Source();
 		return defaultSource.generate(timestamp);
 	}
 
@@ -125,8 +108,10 @@ namespace Snowflake {
 		return Number.parseInt(value.substring(8, 16), 16) & MAX_SEQ;
 	}
 	export function getTimestamp(value: Snowflake) {
-		const n = toBigInt(value) >> 22n;
-		return Number(n + BigInt(EPOCH));
+		const hi = Number.parseInt(value.substring(0, 8), 16);
+		const lo = Number.parseInt(value.substring(8, 16), 16);
+		// (hi:lo) >> 22 == hi * 2^10 + (lo >>> 22); at most ~2^42, exact in a double.
+		return hi * 1024 + (lo >>> 22) + EPOCH;
 	}
 	export function getDate(value: Snowflake) {
 		return new Date(getTimestamp(value));