ompchamber 3.3.1 → 3.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ompchamber",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "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/assets/font-css.server.test.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `/fonts.css` is derived from the SOURCE stylesheets on every request, and this
+ * is the gate that keeps it that way.
+ *
+ * The sheet used to be assembled from a directory the bundler wrote as a side
+ * effect of bundling a CSS module — so it was produced once per process and
+ * could never be repaired. An `rm -rf` while the server ran, or a fresh clone
+ * that never built, left the route answering 0 bytes for the rest of that
+ * process and the terminal's Nerd symbols face vanished: private-use glyphs
+ * became tofu boxes with no error anywhere. These assertions fail if the sheet
+ * ever depends on a build artifact again.
+ *
+ * The last case is the end-to-end one: every font basename the sheet names must
+ * resolve to a file the server actually serves. A face pointing at a basename
+ * no package ships is a 404 the browser swallows, which looks identical to the
+ * font never having been declared.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { fontStylesheet, serveFontFile } from '@/server/lib/assets/font-css.server';
+import { packageDir } from '@/server/lib/assets/fonts.server';
+
+const sheet = await fontStylesheet();
+
+/** Every `url(...)` target in the sheet. */
+function urls(css: string): string[] {
+  return [...css.matchAll(/url\(\s*(['"]?)([^'")]+)\1\s*\)/g)].map(([, , target]) => target);
+}
+
+describe('/fonts.css is assembled from source, not from a build artifact', () => {
+  test('it declares the bundled Nerd symbols face', () => {
+    expect(sheet).toContain('OMPChamber Nerd Symbols');
+    expect(urls(sheet)).toContain('/fonts/symbols-nerd-font-mono.woff2');
+    // The range is what keeps the 1.1 MB face off every machine that has a
+    // Nerd Font of its own, so a sheet without it is a different contract.
+    expect(sheet).toContain('unicode-range');
+  });
+
+  test('it declares the text faces the bundle cannot carry', () => {
+    expect(sheet).toContain('Fira Code');
+    expect(sheet).toContain('KaTeX_Main');
+    expect(urls(sheet)).toContain('/fonts/fira-code-latin-400-normal.woff2');
+  });
+
+  test('every url is rewritten to the served route — no relative or node_modules path survives', () => {
+    const targets = urls(sheet);
+    expect(targets.length).toBeGreaterThan(20);
+    for (const target of targets) {
+      expect(target.startsWith('/fonts/')).toBe(true);
+    }
+  });
+
+  test('every basename the sheet names resolves to a served file', async () => {
+    for (const target of urls(sheet)) {
+      const response = await serveFontFile(target.slice('/fonts/'.length));
+      expect(response).not.toBeNull();
+      expect(response?.headers.get('content-type')).toMatch(/^font\//);
+    }
+  });
+});
+
+describe('the source tree is resolved by the package, not by the dependencies', () => {
+  // In a hoisted install the package's own files live under
+  // `node_modules/ompchamber/` while its dependencies sit in the parent
+  // `node_modules/` — so `packageRoot()` (the first root holding
+  // `node_modules`) is the PARENT, and looking for `src/` beside the hoisted
+  // packages finds nothing. That served an empty sheet and silently dropped
+  // every `@font-face`; the stylesheet has to resolve through `packageDir()`.
+  test('the stylesheets resolve through packageDir, and it finds the source tree', () => {
+    // This repo is a source checkout, where `packageDir()` and `packageRoot()`
+    // coincide. The assertion that matters is that the source tree is found AT
+    // ALL — the hoisted layout above is the case that breaks, and it cannot be
+    // staged from inside the repo without rewriting the module's own search
+    // roots, so the end-to-end proof for it lives in the manual run against a
+    // simulated published install.
+    expect(existsSync(join(packageDir(), 'src'))).toBe(true);
+    expect(existsSync(join(packageDir(), 'src', 'shared', 'lib', 'fonts', 'nerd-symbols.css'))).toBe(true);
+  });
+});

package/src/server/lib/assets/font-css.server.ts

@@ -10,32 +10,44 @@
  * local `url()`, and a font is always a local file — so a bundled face is either
  * a base64 blob or an absolute filesystem path. `lib/bundler/css.ts` lifts each
  * block out of its stylesheet and rewrites the urls to `<FONT_ROUTE_PREFIX><basename>`;
- * this module serves the result.
+ * this module re-declares them on `/fonts.css`.
  *
  * Two jobs, one route each:
  *
- * - `FONT_STYLESHEET_ROUTE` (`/fonts.css`) concatenates the extracted faces.
- *   Read per request rather than cached: it is a handful of kilobytes, and a
- *   cache is what would keep a stale face alive across an edit to a stylesheet.
- *   A missing directory is an empty stylesheet, not a 404 — the shell links this
- *   unconditionally.
+ * - `FONT_STYLESHEET_ROUTE` (`/fonts.css`) concatenates the faces, read from the
+ *   source stylesheets under `src/` on every request. It is a handful of
+ *   kilobytes and four small files, and reading them is what keeps the sheet
+ *   correct for the process's whole life — the alternative, a directory the
+ *   bundler wrote, is only ever produced as a side effect of a CSS module being
+ *   bundled, so it is written once per process and can never be repaired: an
+ *   `rm -rf` while the server runs (or a fresh clone that never ran a build)
+ *   leaves `/fonts.css` empty for the rest of that process, and the terminal's
+ *   Nerd symbols face silently disappears — the glyphs become tofu boxes with no
+ *   error anywhere.
+ *
+ *   Only a face whose `src` names a local font is re-declared, so a stylesheet
+ *   carrying a remote face contributes nothing (see `font-faces.ts`). The faces
+ *   the client bundle imports all live under `src/`, which is what makes the
+ *   source tree the honest place to read them from: the same files the bundler
+ *   strips are the files the browser is served.
  *
  * - `FONT_ROUTE_PREFIX` (`/fonts/<basename>`) serves the file itself from the
  *   installed packages. The basename is the whole key, so the lookup is an index
  *   rather than a path built from the request; see `fonts.server.ts`.
  */
 
-import { join } from 'path';
+import { dirname, join } from 'path';
 import { Glob } from 'bun';
 
-import { packageRoot, resolveFontFile } from '@/server/lib/assets/fonts.server';
-
-/** Directory holding one extracted face file per source stylesheet. */
-export const FONT_FACE_DIR = join('.ompchamber-build', 'font-faces');
+import { splitFontFaces } from '@/server/lib/assets/font-faces';
+import { packageDir, resolveFontFile } from '@/server/lib/assets/fonts.server';
 
 /** The route the assembled stylesheet is served on. */
 export const FONT_STYLESHEET_ROUTE = '/fonts.css';
 
+/** Where the stylesheets that carry faces live, relative to the package directory. */
+const STYLE_SOURCE_ROOT = 'src';
+
 const FONT_MIME: Record<string, string> = {
   '.woff2': 'font/woff2',
   '.woff': 'font/woff',
@@ -48,20 +60,34 @@ const STYLESHEET_HEADERS = {
   'cache-control': 'no-store',
 } as const;
 
-/** Every extracted face file, concatenated in a stable order. */
-export async function fontStylesheet(): Promise<string> {
-  const dir = join(packageRoot(), FONT_FACE_DIR);
-  const glob = new Glob('*.css');
+/** The absolute path of every stylesheet under the package's `src/`, sorted. */
+function sourceStylesheets(): string[] {
+  const root = join(packageDir(), STYLE_SOURCE_ROOT);
+  const glob = new Glob('**/*.css');
   const files: string[] = [];
   try {
-    for await (const file of glob.scan({ cwd: dir, onlyFiles: true })) files.push(file);
+    for (const file of glob.scanSync({ cwd: root, onlyFiles: true })) files.push(join(root, file));
   } catch {
-    return '';
+    return [];
   }
-  // Sorted so the stylesheet is byte-stable between builds: the browser caches
-  // on the ETag, and an unstable order would invalidate it for no change.
+  // Sorted so the stylesheet is byte-stable between requests: the browser
+  // caches on the ETag, and an unstable order would invalidate it for no change.
   files.sort();
-  const parts = await Promise.all(files.map((file) => Bun.file(join(dir, file)).text()));
+  return files;
+}
+
+/** Every `@font-face` block the source stylesheets declare, concatenated. */
+export async function fontStylesheet(): Promise<string> {
+  const parts: string[] = [];
+  for (const path of sourceStylesheets()) {
+    // A read that fails contributes nothing rather than failing the sheet: the
+    // shell links this unconditionally, and one unreadable file must not take
+    // the faces beside it down with it.
+    const css = await Bun.file(path).text().catch(() => '');
+    if (!css) continue;
+    const { faces } = splitFontFaces(css, dirname(path));
+    if (faces.length > 0) parts.push(...faces);
+  }
   return parts.join('\n');
 }
 

package/src/server/lib/assets/font-faces.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Pulling `@font-face` blocks out of a stylesheet, and pointing their `url()`s
+ * at the served route.
+ *
+ * Two callers, one reason to share: the bundler's CSS loader strips faces out
+ * of every module it bundles (`lib/bundler/css.ts`) because Bun resolves each
+ * local `url()` into base64 or an absolute filesystem path, and the server
+ * assembles `/fonts.css` from the same stylesheets
+ * (`lib/assets/font-css.server.ts`). The two must agree byte for byte — a face
+ * stripped from the bundle has to be the one the stylesheet re-declares, or the
+ * font silently never loads.
+ *
+ * Only a block whose `src` names a LOCAL font moves: a face pointing at a
+ * remote url is valid CSS the bundle can keep. `rewriteFontUrls` replaces every
+ * local font url with `<FONT_ROUTE_PREFIX><basename>`, which is the only form
+ * that survives Bun's loader — a same-origin path is not an escape hatch, since
+ * `url("/fonts/x.woff2")` fails the build with "Could not resolve".
+ */
+
+import { basename, isAbsolute, resolve as resolvePath } from 'path';
+
+import { FONT_ROUTE_PREFIX } from '@/server/lib/assets/fonts.server';
+
+/** A `url(...)` whose target is a font file. */
+const URL_FUNCTION = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
+const FONT_FILE = /\.(?:woff2?|ttf|otf)$/i;
+/** Schemes Bun leaves alone, and the prefix this module itself emits. */
+const EXTERNAL = /^(?:data:|https?:|blob:|\/\/)/i;
+
+/** One `@font-face` block, braces included. Faces cannot nest. */
+const FONT_FACE = /@font-face\s*\{[^{}]*\}/g;
+
+/** Absolute path of a local font url, or null when it is not one. */
+function localFont(specifier: string, cssDir: string): string | null {
+  if (EXTERNAL.test(specifier) || specifier.startsWith(FONT_ROUTE_PREFIX)) return null;
+  if (!FONT_FILE.test(specifier)) return null;
+  return isAbsolute(specifier) ? specifier : resolvePath(cssDir, specifier);
+}
+
+/** Point every font `url()` at the served path. */
+export function rewriteFontUrls(css: string, cssDir: string): string {
+  return css.replace(URL_FUNCTION, (whole, quote: string, specifier: string) => {
+    const absolute = localFont(specifier, cssDir);
+    if (!absolute) return whole;
+    return `url(${quote}${FONT_ROUTE_PREFIX}${basename(absolute)}${quote})`;
+  });
+}
+
+/**
+ * Split `@font-face` blocks out of a stylesheet.
+ *
+ * `cssDir` resolves a relative `src` url, so it must be the directory of the
+ * file the text came from — not the bundle's.
+ */
+export function splitFontFaces(css: string, cssDir: string): { rest: string; faces: string[] } {
+  const faces: string[] = [];
+  const rest = css.replace(FONT_FACE, (block) => {
+    const hasLocal = [...block.matchAll(URL_FUNCTION)].some(([, , spec]) => localFont(spec, cssDir));
+    if (!hasLocal) return block;
+    faces.push(rewriteFontUrls(block, cssDir));
+    return '';
+  });
+  return { rest, faces };
+}

package/src/server/lib/assets/fonts.server.ts

@@ -77,12 +77,16 @@ let index: Record<string, string> | null = null;
 /**
  * The package root — the first search root that holds `node_modules`.
  *
- * Both ends of the build need the same answer: the plugin writes the extracted
- * face files here and the server reads them back, and an AOT bundle runs from
- * `dist/client` while a source checkout runs from the repo. Falling back to the
+ * The AOT bundle runs from `dist/client` while a source checkout runs from the
+ * repo, and both resolve their dependencies through this. Falling back to the
  * cwd keeps a checkout with no `node_modules` (a publish dry-run) working.
+ *
+ * This answers "where are the DEPENDENCIES", which is not the same question as
+ * `packageDir()` below: a hoisted install keeps the package's own files under
+ * `node_modules/ompchamber/` while its dependencies sit in the parent
+ * `node_modules/`, so the first root holding `node_modules` is the PARENT.
  */
-export function packageRoot(): string {
+function packageRoot(): string {
   for (const root of searchRoots()) {
     // `existsSync` rather than `Bun.file().exists()`: the latter is async and
     // file-only, and `node_modules` is a directory.
@@ -91,6 +95,25 @@ export function packageRoot(): string {
   return process.cwd();
 }
 
+/**
+ * The package's own directory — the first search root that holds `src/`.
+ *
+ * The source stylesheets `lib/assets/font-css.server.ts` reads for `/fonts.css`
+ * live there, and they must be found in every install shape. In a source
+ * checkout and a non-hoisted install this is the same directory
+ * `packageRoot()` returns; in a hoisted install it is the package under
+ * `node_modules/`, one level BELOW the root that holds the dependencies.
+ * Resolving the source tree through `packageRoot()` there would look for
+ * `src/` beside the hoisted packages and find nothing, which serves an empty
+ * stylesheet and silently drops every `@font-face`.
+ */
+export function packageDir(): string {
+  for (const root of searchRoots()) {
+    if (existsSync(join(root, 'src'))) return root;
+  }
+  return packageRoot();
+}
+
 async function buildIndex(): Promise<Record<string, string>> {
   const found: Record<string, string> = {};
   const glob = new Glob('*.{woff2,woff,ttf,otf}');

package/src/server/lib/bundler/build-errors.server.ts

@@ -33,9 +33,9 @@
 import { join, relative } from 'path';
 import type { BuildOutput, BunPlugin } from 'bun';
 
-import { packageRoot } from '@/server/lib/assets/fonts.server';
+import { packageDir } from '@/server/lib/assets/fonts.server';
 
-/** The shell bundle's entrypoint, relative to the package root. */
+/** The shell bundle's entrypoint, relative to the package directory. */
 const SHELL_ENTRYPOINT = 'index.html';
 
 /** Bun's own config file, and the section naming the bundle's plugins. */
@@ -109,8 +109,13 @@ function formatLog(log: BundleLog, root: string): string {
 /**
  * The bundle errors behind a shell that would not render, or null when this
  * build is not the reason (a clean bundle means the failure lies elsewhere).
+ *
+ * `root` is the PACKAGE, not `packageRoot()`: the entrypoint is `index.html`
+ * beside the source, and in a hoisted install the first root holding
+ * `node_modules` is the parent, where `index.html` does not exist — so the probe
+ * would report no failure at all and the real build error would never be shown.
  */
-export async function describeShellBuildFailure(root = packageRoot()): Promise<string | null> {
+export async function describeShellBuildFailure(root = packageDir()): Promise<string | null> {
   const entrypoint = join(root, SHELL_ENTRYPOINT);
   if (!(await Bun.file(entrypoint).exists())) return null;
 

package/src/server/lib/bundler/css.ts

@@ -30,18 +30,17 @@
  *    rewrite inside the bundle can work.
  *
  *    The faces therefore leave the bundle. Each block is rewritten to
- *    `<FONT_ROUTE_PREFIX><basename>` and written to its own file under
- *    `FONT_FACE_DIR`, keyed by the stylesheet it came from — a document Bun
- *    never parses, which is what lets the urls survive. The server concatenates
- *    that directory into `/fonts.css` (`lib/assets/font-css.server.ts`) and the
- *    shell links it, so the layout rules stay bundled while the faces stay
+ *    `<FONT_ROUTE_PREFIX><basename>` and dropped from the module, and the server
+ *    re-declares them on `/fonts.css` from the SAME source stylesheets
+ *    (`lib/assets/font-css.server.ts`, `lib/assets/font-faces.ts`). The shell
+ *    links that route, so the layout rules stay bundled while the faces stay
  *    cacheable files.
  *
- *    Per-source files rather than one accumulated file because `onEnd` is NOT
- *    invoked by `serve.static` (verified: `onStart` and `onLoad` fire, `onEnd`
- *    never does), so there is no "build finished" moment to flush at. Writing
- *    each source's faces as its `onLoad` returns is order-independent and works
- *    identically under both entry points.
+ *    The server derives the faces from source rather than from a directory this
+ *    plugin wrote, because `onEnd` is NOT invoked by `serve.static` (verified:
+ *    `onStart` and `onLoad` fire, `onEnd` never does) and a written artifact is
+ *    produced exactly once per process — a `rm -rf` after boot, or a fresh clone
+ *    that never built, would leave `/fonts.css` empty for good.
  *
  * 3. **Nested at-rules are flattened** (`flattenNestedAtRules`, registered
  *    AFTER Tailwind so it sees the expanded tree). Bun's CSS minifier keeps the
@@ -53,57 +52,14 @@
  *    the measurement; this one only has to run it.
  */
 
-import { basename, dirname, isAbsolute, join, resolve as resolvePath } from 'path';
+import { dirname } from 'path';
 import postcss from 'postcss';
 import tailwind from '@tailwindcss/postcss';
 import type { BunPlugin } from 'bun';
 
-import { FONT_FACE_DIR } from '@/server/lib/assets/font-css.server';
-import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server';
+import { splitFontFaces } from '@/server/lib/assets/font-faces';
 import { flattenNestedAtRules } from '@/server/lib/bundler/nested-at-rules';
 
-/** A `url(...)` whose target is a font file. */
-const URL_FUNCTION = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
-const FONT_FILE = /\.(?:woff2?|ttf|otf)$/i;
-/** Schemes Bun leaves alone, and the prefix this plugin itself emits. */
-const EXTERNAL = /^(?:data:|https?:|blob:|\/\/)/i;
-
-/** One `@font-face` block, braces included. Faces cannot nest. */
-const FONT_FACE = /@font-face\s*\{[^{}]*\}/g;
-
-/** Absolute path of a local font url, or null when it is not one. */
-function localFont(specifier: string, cssDir: string): string | null {
-  if (EXTERNAL.test(specifier) || specifier.startsWith(FONT_ROUTE_PREFIX)) return null;
-  if (!FONT_FILE.test(specifier)) return null;
-  return isAbsolute(specifier) ? specifier : resolvePath(cssDir, specifier);
-}
-
-/** Point every font `url()` at the served path. */
-function rewriteFontUrls(css: string, cssDir: string): string {
-  return css.replace(URL_FUNCTION, (whole, quote: string, specifier: string) => {
-    const absolute = localFont(specifier, cssDir);
-    if (!absolute) return whole;
-    return `url(${quote}${FONT_ROUTE_PREFIX}${basename(absolute)}${quote})`;
-  });
-}
-
-/**
- * Split `@font-face` blocks out of a stylesheet.
- *
- * Only blocks whose `src` names a local font move: a face pointing at a remote
- * url is valid CSS the bundle can keep.
- */
-function splitFontFaces(css: string, cssDir: string): { rest: string; faces: string[] } {
-  const faces: string[] = [];
-  const rest = css.replace(FONT_FACE, (block) => {
-    const hasLocal = [...block.matchAll(URL_FUNCTION)].some(([, , spec]) => localFont(spec, cssDir));
-    if (!hasLocal) return block;
-    faces.push(rewriteFontUrls(block, cssDir));
-    return '';
-  });
-  return { rest, faces };
-}
-
 const plugin: BunPlugin = {
   name: 'ompchamber-css',
   setup(build) {
@@ -117,12 +73,7 @@ const plugin: BunPlugin = {
       const expanded = await postcss([tailwind(), flattenNestedAtRules()]).process(source, {
         from: args.path,
       });
-      const { rest, faces } = splitFontFaces(expanded.css, dirname(args.path));
-      if (faces.length > 0) {
-        const target = join(packageRoot(), FONT_FACE_DIR, `${basename(args.path)}`);
-        const header = `/* GENERATED from ${args.path} — do not edit. */\n`;
-        await Bun.write(target, header + faces.join('\n') + '\n');
-      }
+      const { rest } = splitFontFaces(expanded.css, dirname(args.path));
       return { contents: rest, loader: 'css' };
     });
   },

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);
       },
     }),