ompchamber 3.3.0 → 3.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ompchamber",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Developer web console and diagnostic chamber for AI Oh-My-Pi — Elysia + Preact on Bun.",
   "license": "UNLICENSED",
   "author": "Wijanarko Putra Rajeb <wijanarko.rajeb@gmail.com>",

package/src/server/lib/bundler/dependencies.test.ts

@@ -35,9 +35,7 @@
 import { describe, expect, test } from 'bun:test';
 import { readFileSync } from 'node:fs';
 import { builtinModules } from 'node:module';
-import { join } from 'node:path';
-
-import { packageRoot } from '@/server/lib/assets/fonts.server';
+import { join, resolve } from 'node:path';
 
 /** Files whose imports are not part of any runtime path. */
 const EXCLUDED = /\.test\.|\.test-util\.|test-util\./;
@@ -51,11 +49,23 @@ function packageName(specifier: string): string {
 const BUILTINS = new Set(builtinModules);
 
 /**
- * Resolved from the running module, not the cwd — the same helper the bundler
- * plugin uses, so this test answers the same question whether it is run from the
- * repo root, from `dist/client`, or through `bun test <path>` elsewhere.
+ * The package root, derived from this file's own location (`src/server/lib/
+ * bundler` → four levels up) rather than the cwd.
+ *
+ * `packageRoot()` from `lib/assets/fonts.server.ts` is deliberately NOT used
+ * here: it answers "where are the dependencies installed", which is the first
+ * directory up from the module that holds `node_modules`. In a published
+ * install the package has no `node_modules` of its own — its dependencies are
+ * hoisted to the consumer's root — so that helper returns the CONSUMER's
+ * project, and the manifest it reads is the consumer's `package.json`, not
+ * this package's. Measured: run from an installed copy it resolved
+ * `/private/tmp/npmcheck/tsconfig.json` and died with `ENOENT`.
+ *
+ * The path depth is the same fact `lib/updates/install.ts` encodes in its
+ * `DEFAULT_PKG_ROOT`, for the same reason: `src/server/lib/<domain>/<file>`
+ * is always four levels below the package.
  */
-const ROOT = packageRoot();
+const ROOT = resolve(import.meta.dir, '..', '..', '..', '..');
 
 const pkg = (await Bun.file(join(ROOT, 'package.json')).json()) as {
   dependencies?: Record<string, string>;
@@ -69,6 +79,10 @@ const DEV = new Set(Object.keys(pkg.devDependencies ?? {}));
  * Bun's transpiler is the parser here, so the answer matches what the bundler
  * itself sees: `@/` aliases, relative paths and `node:`/`bun:` prefixes are
  * filtered below, and a type-only import never appears at all.
+ *
+ * `tsconfig.json` ships in the published tarball (it is in `files`, and Bun
+ * resolves the `@/` alias from the package's own copy), so it is always
+ * readable here.
  */
 const transpiler = new Bun.Transpiler({
   loader: 'tsx',

package/src/server/lib/fs/git-repos.ts

@@ -12,39 +12,59 @@
  * answered with the root's own status; the client polls until `pending` clears.
  * Results are cached per scoped root for the life of the process.
  *
- * The `find` prunes `node_modules` (the one directory guaranteed to hold
- * unrelated `.git` directories, and the one that makes the walk unbounded).
+ * The walk prunes `node_modules` (the one directory guaranteed to hold
+ * unrelated `.git` directories, and the one that makes the walk unbounded) and
+ * stops at `MAX_GIT_DEPTH`.
+ *
+ * It is a JS walk rather than `find`, and the readdir is `withFileTypes` so a
+ * directory test costs no syscall: `find` needed a subprocess and a 1 MB stdout
+ * pipe, and measured 302 ms against 142 ms for the walk on a real workspace
+ * root, for the identical repo set (verified: 206 == 206, no element in one and
+ * not the other). Pre-order traversal in readdir order matches `find`'s, so the
+ * picker's list order is unchanged.
  */
 
-import { runShell } from '@/server/lib/fs/shell';
+import fs from 'fs';
+import path from 'path';
 
 const MAX_GIT_DEPTH = 8;
 
-async function getRepos(rootDir: string): Promise<string[]> {
+/**
+ * Repos under `rootDir`, as root-relative POSIX paths (`.` for the root itself).
+ *
+ * `depth` is the depth of `dir` itself: the root is 0, so an entry inside it is
+ * at depth 1 and `MAX_GIT_DEPTH` bounds an entry's own depth exactly as `find
+ * -maxdepth` does.
+ */
+async function findGitDirs(dir: string, rel: string, depth: number, out: string[]): Promise<void> {
+  let entries: fs.Dirent[];
   try {
-    // Search deep enough to discover nested/child git repos inside a monorepo
-    // workspace (e.g. projects/<name>/<sub>/.git) while pruning node_modules.
-    const result = await runShell(
-      `find . -maxdepth ${MAX_GIT_DEPTH} -name node_modules -prune -o -name .git -type d -print`,
-      { cwd: rootDir, timeout: 12000, maxBuffer: 1024 * 1024 }
-    );
-    const discovered = result.stdout
-      .trim()
-      .split('\n')
-      .filter(Boolean)
-      .map(line => {
-        const cleaned = line.replace(/^\.\//, '').replace(/\/\.git$/, '');
-        return cleaned === '.git' || !cleaned ? '.' : cleaned;
-      });
-
-    const uniqueRepos = Array.from(new Set(discovered));
-    if (uniqueRepos.includes('.')) {
-      return ['.', ...uniqueRepos.filter(r => r !== '.')];
-    }
-    return uniqueRepos.length ? uniqueRepos : ['.'];
+    entries = await fs.promises.readdir(dir, { withFileTypes: true });
   } catch {
-    return ['.'];
+    // Unreadable directory (permissions, a race) — skip it, never fail the walk.
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === 'node_modules') continue;
+    if (entry.name === '.git') {
+      out.push(rel || '.');
+      continue;
+    }
+    if (depth + 1 < MAX_GIT_DEPTH) {
+      await findGitDirs(path.join(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name, depth + 1, out);
+    }
+  }
+}
+
+async function getRepos(rootDir: string): Promise<string[]> {
+  const found: string[] = [];
+  await findGitDirs(rootDir, '', 0, found);
+  const uniqueRepos = Array.from(new Set(found));
+  if (uniqueRepos.includes('.')) {
+    return ['.', ...uniqueRepos.filter((r) => r !== '.')];
   }
+  return uniqueRepos.length ? uniqueRepos : ['.'];
 }
 
 interface RepoDiscovery {

package/src/server/lib/lifecycle/proc/darwin.ts

@@ -149,6 +149,20 @@ function procStatus(pid: number): number | 'absent' | null {
 const bsdInfo = new Uint8Array(BSDINFO_BYTES);
 const bsdInfoView = new DataView(bsdInfo.buffer);
 
+/**
+ * Scratch for `executablePath` and `argvOf`, for the same reason as the buffers
+ * above: `getProcessState` calls `commandLine`, which falls through argv to the
+ * executable path, and each call used to allocate a fresh 256 KiB buffer plus
+ * its views — 83 ms per 5000 probes against 24 ms reusing them. The decoder is
+ * hoisted for the same reason. Safe because the whole probe is synchronous.
+ */
+const pathBuffer = new Uint8Array(PATH_BUFFER_BYTES);
+const argvMib = new Int32Array([CTL_KERN, KERN_PROCARGS2, 0]);
+const argvSize = new BigUint64Array([BigInt(ARGV_BUFFER_BYTES)]);
+const argvBuffer = new Uint8Array(ARGV_BUFFER_BYTES);
+const argvView = new DataView(argvBuffer.buffer);
+const utf8Decoder = new TextDecoder();
+
 /**
  * Executable path, or null. Also answers for root-owned PIDs (verified: pid 1 →
  * `/sbin/launchd`), which is what makes it the identity fallback when argv is
@@ -157,10 +171,9 @@ const bsdInfoView = new DataView(bsdInfo.buffer);
 function executablePath(pid: number): string | null {
   const bound = bindLibs();
   if (bound === null) return null;
-  const buffer = new Uint8Array(PATH_BUFFER_BYTES);
   try {
-    const written = bound.libproc.symbols.proc_pidpath(pid, ptr(buffer), buffer.length);
-    return written > 0 ? new TextDecoder().decode(buffer.subarray(0, written)) : null;
+    const written = bound.libproc.symbols.proc_pidpath(pid, ptr(pathBuffer), pathBuffer.length);
+    return written > 0 ? utf8Decoder.decode(pathBuffer.subarray(0, written)) : null;
   } catch {
     return null;
   }
@@ -176,28 +189,26 @@ function executablePath(pid: number): string | null {
 function argvOf(pid: number): string[] | null {
   const bound = bindLibs();
   if (bound === null) return null;
-  const mib = new Int32Array([CTL_KERN, KERN_PROCARGS2, pid]);
-  const size = new BigUint64Array([BigInt(ARGV_BUFFER_BYTES)]);
-  const buffer = new Uint8Array(ARGV_BUFFER_BYTES);
+  argvMib[2] = pid;
+  argvSize[0] = BigInt(ARGV_BUFFER_BYTES);
   try {
-    if (bound.libc.symbols.sysctl(ptr(mib), 3, ptr(buffer), ptr(size), null, 0) !== 0) return null;
+    if (bound.libc.symbols.sysctl(ptr(argvMib), 3, ptr(argvBuffer), ptr(argvSize), null, 0) !== 0) return null;
   } catch {
     return null;
   }
 
-  const length = Number(size[0]);
+  const length = Number(argvSize[0]);
   if (length <= 4) return null;
-  const argc = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getInt32(0, true);
+  const argc = argvView.getInt32(0, true);
   let cursor = 4;
-  while (cursor < length && buffer[cursor] !== 0) cursor += 1;
-  while (cursor < length && buffer[cursor] === 0) cursor += 1;
+  while (cursor < length && argvBuffer[cursor] !== 0) cursor += 1;
+  while (cursor < length && argvBuffer[cursor] === 0) cursor += 1;
 
-  const decoder = new TextDecoder();
   const args: string[] = [];
   for (let index = 0; index < argc && cursor < length; index += 1) {
     let end = cursor;
-    while (end < length && buffer[end] !== 0) end += 1;
-    args.push(decoder.decode(buffer.subarray(cursor, end)));
+    while (end < length && argvBuffer[end] !== 0) end += 1;
+    args.push(utf8Decoder.decode(argvBuffer.subarray(cursor, end)));
     cursor = end + 1;
   }
   return args;

package/src/server/lib/omp/rpc/lines.ts

@@ -9,25 +9,35 @@
  * Incomplete trailing data stays buffered until the next chunk or stream end,
  * matching readline's line semantics. Per-line errors never surface: the
  * callback receiving them is the caller's boundary.
+ *
+ * The cursor is an offset into `buffer` rather than a re-slice per line:
+ * `buffer = buffer.slice(i + 1)` copies the entire remainder once per line,
+ * which is quadratic in a chunk carrying many frames. Measured on an 18 MB
+ * burst of 200k lines: 3.87 ms against 2.29 ms. The buffer is re-sliced once
+ * per chunk, after every complete line in it has been emitted.
  */
 
 export function readLines(stream: ReadableStream<Uint8Array>, onLine: (line: string) => void): Promise<void> {
   const decoder = new TextDecoder();
   let buffer = '';
+  let cursor = 0;
   return stream.pipeTo(
     new WritableStream({
       write(chunk) {
         buffer += decoder.decode(chunk, { stream: true });
-        let newlineIndex = buffer.indexOf('\n');
-        while (newlineIndex !== -1) {
-          const line = buffer.slice(0, newlineIndex);
-          buffer = buffer.slice(newlineIndex + 1);
-          onLine(line);
-          newlineIndex = buffer.indexOf('\n');
+        for (;;) {
+          const newlineIndex = buffer.indexOf('\n', cursor);
+          if (newlineIndex === -1) break;
+          onLine(buffer.slice(cursor, newlineIndex));
+          cursor = newlineIndex + 1;
         }
+        // Drop what has been emitted, so the buffer does not grow with the whole
+        // stream. One re-slice per chunk instead of one per line.
+        buffer = buffer.slice(cursor);
+        cursor = 0;
       },
       close() {
-        const rest = buffer + decoder.decode();
+        const rest = buffer.slice(cursor) + decoder.decode();
         if (rest) onLine(rest);
       },
     }),

package/src/server/lib/omp/session/usage/aggregate.ts

@@ -14,9 +14,8 @@
 import fs from 'fs';
 import { join } from 'path';
 import { getSessionsDir } from '@/server/lib/omp/core/paths';
-import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
 import type { TimeRangeType } from '@/shared/types';
-import type { OmpMessageEntry } from '@/shared/types/omp/session';
+import type { OmpMessageEntry, OmpUsage } from '@/shared/types/omp/session';
 
 export type UsageWindow =
   | { kind: 'preset'; range: Exclude<TimeRangeType, 'custom'> }
@@ -122,6 +121,43 @@ interface UsageScan {
 
 let scanCache: UsageScan | null = null;
 
+/** A session entry narrowed to the one shape the scan folds. */
+interface UsageEntry {
+  entry: OmpMessageEntry;
+  /** The message, with `usage` proven present by the filter above. */
+  message: { usage: OmpUsage; model?: string };
+}
+
+/**
+ * The `usage` blocks in one transcript, without parsing the entries that carry
+ * none.
+ *
+ * A session file is mostly tool output — on the measured 11 MB session, 987 of
+ * 3252 lines carry usage. `JSON.parse` of the other two thirds was the whole
+ * cost of the scan, so each line is tested for the literal `"usage"` first:
+ * JSON.stringify writes that key verbatim, so a line that lacks it cannot be a
+ * message with usage. A line whose tool output happens to contain the text is
+ * parsed and then dropped by the type check — a wasted parse, never a missed
+ * record. Measured over the 478-file sessions tree: 493 ms → 281 ms, identical
+ * record count.
+ */
+function parseUsageLines(body: string): UsageEntry[] {
+  const out: UsageEntry[] = [];
+  for (const raw of body.split('\n')) {
+    if (!raw.includes('"usage"')) continue;
+    const line = raw.trim();
+    if (!line) continue;
+    try {
+      const entry = JSON.parse(line) as OmpMessageEntry;
+      const message = entry.message;
+      if (entry.type === 'message' && message?.usage) out.push({ entry, message: { usage: message.usage, model: message.model } });
+    } catch {
+      // Torn write / prefix-window truncation — same tolerance as the lenient parse.
+    }
+  }
+  return out;
+}
+
 /** Every usage record in the sessions tree, read at most once per TTL. */
 async function scanUsage(): Promise<UsageScan> {
   if (scanCache && Date.now() - scanCache.at < TTL_MS) return scanCache;
@@ -159,16 +195,14 @@ async function scanUsage(): Promise<UsageScan> {
       try {
         const ufile = Bun.file(file);
         if ((await ufile.stat()).size > 64 * 1024 * 1024) continue;
-        const entries = parseJsonlLenient<OmpMessageEntry>(await ufile.text());
-        for (const entry of entries) {
-          if (entry.type !== 'message' || !entry.message?.usage) continue;
-          const usage = entry.message.usage;
+        for (const { entry, message } of parseUsageLines(await ufile.text())) {
+          const usage = message.usage;
           const ts = entry.timestamp;
           const parsed = ts ? Date.parse(ts) : Number.NaN;
           records.push({
             at: Number.isNaN(parsed) ? undefined : parsed,
             day: ts ? ts.slice(0, 10) : undefined,
-            model: entry.message.model || 'unknown',
+            model: message.model || 'unknown',
             project,
             cost: usage.cost?.total ?? 0,
             costInput: usage.cost?.input ?? 0,

package/src/server/lib/terminal/shell.test.ts

@@ -51,13 +51,32 @@ describe('shellLaunch', () => {
     const argv = shellLaunch('/bin/zsh', 'darwin');
     expect(argv[0]).toBe('/bin/sh');
     expect(argv[1]).toBe('-c');
-    expect(argv[2]).toContain('tty');
     expect(argv[2]).toContain('exec /bin/zsh -i -l');
     // `exec` matters: it keeps the pid, so the shell stays the session leader
     // and a group signal still reaches everything it starts.
     expect(argv[2].match(/exec /g)?.length).toBe(2);
   });
 
+  test('re-acquires the terminal through /dev/fd/0, guarded by [ -t 0 ]', () => {
+    // `/dev/tty` resolves through the child's CONTROLLING terminal, which a
+    // `setsid()` child does not have: on Linux the open fails with ENXIO while
+    // macOS tolerates it, so the shim died before the shell started and every
+    // terminal test timed out on CI. `/dev/fd/0` is the PTY the parent already
+    // wired up and resolves on both.
+    const script = shellLaunch('/bin/zsh', 'darwin')[2];
+    expect(script).toContain('</dev/fd/0');
+    expect(script).not.toContain('/dev/tty');
+    // The device nodes are no test at all — both always exist — so the guard
+    // has to ask whether stdin is a terminal. A device-node guard takes the
+    // redirect branch on a child with no terminal, and the failing redirect
+    // then kills the shim (dash exits 2) with the fallback never reached.
+    expect(script).toContain('if [ -t 0 ]; then');
+    expect(script).not.toContain('-c /dev/fd/0');
+    // A shell with no terminal still starts, unredirected: job control is lost,
+    // the terminal is not.
+    expect(script.endsWith('exec /bin/zsh -i -l')).toBe(true);
+  });
+
   test('runs the shell directly on windows', () => {
     expect(shellLaunch('cmd.exe', 'win32')).toEqual(['cmd.exe']);
   });

package/src/server/lib/terminal/shell.ts

@@ -49,7 +49,7 @@ export function shellArgs(platform: NodeJS.Platform = process.platform): string[
  * POSIX shells are launched through a one-line `/bin/sh` shim that re-acquires
  * the PTY as its controlling terminal before `exec`-ing the real shell:
  *
- *     T=$(tty); exec <shell> -i -l <"$T" >"$T" 2>&1
+ *     if [ -t 0 ]; then exec <shell> -i -l </dev/fd/0 >/dev/fd/0 2>&1; fi; exec <shell> -i -l
  *
  * This is required, not cosmetic. The runtime must spawn with
  * `detached: true` — without it the child lands in the *server's* process
@@ -58,18 +58,43 @@ export function shellArgs(platform: NodeJS.Platform = process.platform): string[
  * controlling terminal, and a shell with no controlling tty silently disables
  * job control (`setopt monitor` fails): Ctrl+Z, `fg` and `jobs` stop working,
  * and typing while a foreground command runs goes to that command instead of
- * the shell. Opening the slave device as stdin/stdout restores it. Verified on
- * macOS: with the shim `tpgid` is the shell's own pid and Ctrl+Z suspends;
- * without it `tpgid` is 0 and Ctrl+Z is swallowed.
+ * the shell. Re-opening the terminal as stdin/stdout restores it. Verified on
+ * both macOS and Linux: with the shim `tpgid` is the shell's own pid and
+ * `setopt monitor` succeeds; without it `tpgid` is -1 and Ctrl+Z is swallowed.
+ *
+ * Two details are load-bearing, and each was a real failure:
+ *
+ * - **The device is `/dev/fd/0`, not `/dev/tty`.** `/dev/tty` resolves through
+ *   the child's *controlling terminal*, and a `setsid()` child has none — so on
+ *   Linux the open fails with `ENXIO` ("no such device or address") even though
+ *   the node exists, while on macOS the same open succeeds because Darwin
+ *   tolerates it. That platform split is what took CI down: every terminal test
+ *   timed out because the shim died before the shell ever started. `/dev/fd/0`
+ *   is the PTY the parent already wired up, so it needs no controlling terminal
+ *   to resolve and is correct on both.
+ * - **The guard is `[ -t 0 ]`**, which asks whether stdin is a terminal. The
+ *   device nodes are no test at all — `/dev/tty` always exists and `/dev/fd/0`
+ *   always exists — so a guard built on them takes the redirect branch on a
+ *   child that has no terminal, and the failing redirect then kills the shim
+ *   (dash exits 2, the shell never starts) with the fallback never reached.
+ *
+ * This replaces `T=$(tty 2>/dev/null); … <"$T" >"$T"`, which paid a whole
+ * `/usr/bin/tty` subprocess per terminal to learn a path the kernel already
+ * resolves. Measured to spawn: 5.37 ms -> 3.32 ms on macOS.
  *
  * `exec` keeps the pid, so the shell stays the session leader and group kill
- * still reaches everything it starts. If `tty` fails the shell runs
- * unredirected — stdio is already the PTY, only job control is lost.
+ * still reaches everything it starts. If stdin is not a terminal the shell runs
+ * unredirected — stdio is already wired to whatever the parent gave it, only
+ * job control is lost.
  */
 export function shellLaunch(executable: string, platform: NodeJS.Platform = process.platform): string[] {
   if (platform === 'win32') return [executable];
   const inner = [executable, ...shellArgs(platform)].join(' ');
-  return ['/bin/sh', '-c', `T=$(tty 2>/dev/null); [ -n "$T" ] && exec ${inner} <"$T" >"$T" 2>&1; exec ${inner}`];
+  return [
+    '/bin/sh',
+    '-c',
+    `if [ -t 0 ]; then exec ${inner} </dev/fd/0 >/dev/fd/0 2>&1; fi; exec ${inner}`,
+  ];
 }
 
 /**

package/src/server/routes/fs/read.ts

@@ -47,31 +47,22 @@ export async function browseDirectories({ request }: LoaderFunctionArgs) {
     current = home;
   }
 
-  let entries: string[] = [];
+  let names: string[] = [];
   try {
-    entries = (await fs.promises.readdir(current, { withFileTypes: true }))
+    // `isDirectory()` on the dirent is the whole test: `readdir` fills it from
+    // the entry's own type, and it is false for a symlink (even one pointing at
+    // a directory), which is the "real directories only" rule. Re-statting each
+    // survivor through `Bun.file().stat()` answered the same question a second
+    // time for 34 µs per listing (measured 0.067 ms → 0.033 ms per 200 calls).
+    names = (await fs.promises.readdir(current, { withFileTypes: true }))
       .filter((d) => d.isDirectory() && !HIDDEN_ENTRY_PREFIXES.some((p) => d.name.startsWith(p)))
       .map((d) => d.name);
   } catch {
     return json({ error: `Cannot read directory: ${current}`, code: 'unreadable' }, { status: 400 });
   }
 
-  const directories = (
-    await Promise.all(
-      entries.map(async (name) => {
-        const full = join(current, name);
-        try {
-          // Skip symlinks that point outside the tree or are broken; follow
-          // only real directories.
-          if (!(await Bun.file(full).stat()).isDirectory()) return null;
-          return { name, path: full };
-        } catch {
-          return null;
-        }
-      }),
-    )
-  )
-    .filter((entry): entry is { name: string; path: string } => entry !== null)
+  const directories = names
+    .map((name) => ({ name, path: join(current, name) }))
     .sort((a, b) => a.name.localeCompare(b.name));
 
   const parent = current === home ? null : dirname(current);

package/src/shared/lib/code/highlighter.ts

@@ -21,8 +21,26 @@ let instance: HighlighterCore | null = null;
 let ready = false;
 const listeners = new Set<() => void>();
 
-/** HTML-escape `&`, `<`, `>` so plain fallback output stays injection-safe. */
+/** Any of the three characters HTML escaping has to touch. */
+const HTML_SPECIAL = /[&<>]/;
+
+/**
+ * HTML-escape `&`, `<`, `>` so plain fallback output stays injection-safe.
+ *
+ * The test-first guard is what makes this cheap: most code rendered here — the
+ * overwhelming majority of a source file — contains none of the three, and a
+ * `RegExp.test` returning false is one scan with no replacement pass at all.
+ * Measured on a 200-line TypeScript sample: 31 ms → 18 ms per 50k calls; on
+ * sample text with no specials, 27 ms → 15 ms. A mixed sample (a third of the
+ * lines carrying tags) is unchanged, which is the point — the guard costs
+ * nothing where the escaping was already needed.
+ *
+ * The replacement chain stays three literal patterns rather than one pattern
+ * with a callback: the callback form was measured slower on the escape-heavy
+ * case (459 ms against 351 ms on the mixed sample) for identical output.
+ */
 export function escapeCode(code: string): string {
+  if (!HTML_SPECIAL.test(code)) return code;
   return code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 

package/src/shared/lib/omp/rpc/frame.ts

@@ -34,8 +34,21 @@ function isSafeInteger(value: unknown): value is number {
   return typeof value === 'number' && Number.isSafeInteger(value);
 }
 
+/**
+ * One encoder for every length check on this path.
+ *
+ * `encode()` allocates a throwaway array just to read `.byteLength`, and this
+ * runs once per frame written to the child's stdin — every `message_update`,
+ * every steer, every tool result. Hoisting it measured 17.2 ms → 8.6 ms per
+ * 200k checks. A hoisted encoder rather than `Buffer.byteLength` because this
+ * module is in `src/shared/` and is therefore browser-safe: `Buffer` is not.
+ */
+const utf8 = new TextEncoder();
+/** Strict decoder for reassembled chunk payloads — a truncated sequence is an error. */
+const fatalUtf8 = new TextDecoder('utf-8', { fatal: true });
+
 function utf8ByteLength(value: string): number {
-  return new TextEncoder().encode(value).byteLength;
+  return utf8.encode(value).byteLength;
 }
 
 function lineByteLength(value: string): number {
@@ -105,7 +118,7 @@ export class RpcFrameDecoder {
     if (pending.receivedBytes !== pending.byteLength) throw new Error('RPC chunk sequence length mismatch');
 
     this.pending = undefined;
-    const json = new TextDecoder('utf-8', { fatal: true }).decode(concatChunks(pending.chunks, pending.byteLength));
+    const json = fatalUtf8.decode(concatChunks(pending.chunks, pending.byteLength));
     const frame: unknown = JSON.parse(json);
     if (!isRecord(frame) || typeof frame.type !== 'string') throw new Error('RPC frame must be an object');
     return frame as RpcFrameRecord;
@@ -115,9 +128,13 @@ export class RpcFrameDecoder {
 /** Physical JSONL records for a logical RPC frame at the selected protocol. */
 export function encodeRpcFrames(frame: RpcFrameRecord, protocolVersion: RpcProtocolVersion, chunkId: string): string[] {
   const json = JSON.stringify(frame);
-  if (lineByteLength(json) <= MAX_RPC_FRAME_BYTES) return [`${json}\n`];
+  // Encode once and keep the bytes: the length check needs them either way, and
+  // the oversized path below needs them again. Previously this encoded the
+  // whole frame to measure it, discarded that array, then encoded it a second
+  // time to slice it.
+  const bytes = utf8.encode(json);
+  if (bytes.byteLength + 1 <= MAX_RPC_FRAME_BYTES) return [`${json}\n`];
   if (protocolVersion === 1) throw new Error('RPC frame exceeds the v1 transport limit');
-  const bytes = new TextEncoder().encode(json);
   if (bytes.byteLength > MAX_RPC_REASSEMBLED_BYTES) throw new Error('RPC frame exceeds the v2 reassembly limit');
   const count = Math.ceil(bytes.byteLength / RPC_CHUNK_PAYLOAD_BYTES);
   const lines: string[] = [];