ompchamber 3.3.2 → 3.4.0

package/src/client/hooks/chat/btw/mode.ts

@@ -14,28 +14,24 @@
  *
  * `/btw [question]` in the main composer is the entry point; a question that
  * arrived with the command is asked immediately, which is what the TUI does.
+ *
+ * The panel has no model / thinking / access pickers: a side question runs on
+ * the chat's own model and thinking selector and without tools, so a control
+ * here would promise something the child does not read.
  */
 
 import { useCallback, useState } from 'preact/hooks';
-import type { Attachment, BtwDialog, BtwState, BtwTopic, ChatMessageData } from '@/shared/types';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
-import { useBtwSession, type BtwFirstQuestionPicks, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
+import type { Attachment, BtwState, BtwTopic, ChatMessageData } from '@/shared/types';
+import { useBtwSession, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
 import { useChamberEvent } from '@/client/hooks/ui/window-event';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
 import { useSearchParams } from '@/client/lib/router/search-params';
 import { readStreamTransport } from '@/shared/lib/chat/omp/transport';
-import { normalizeApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
-import { readChamberSetting } from '@/shared/lib/settings/client';
 
 /** Question sent when a question arrived carrying only images. */
 const ATTACHMENT_ONLY_QUESTION = 'Describe the attached image.';
 
-/** The composer's persisted access pick, for a topic that has none yet. */
-function readAccessMode(appSettings: Record<string, unknown>): ApprovalMode {
-  return normalizeApprovalMode(readChamberSetting<unknown>('omp_access_mode', appSettings));
-}
-
 export interface BtwMode {
   open: boolean;
   topics: BtwTopic[];
@@ -49,11 +45,6 @@ export interface BtwMode {
   /** What that turn is doing, for the panel's indicator (side stream's own). */
   liveVerb?: string;
   error: string | null;
-  /** Ask/approval dialogs the side child is blocked on, oldest first. */
-  dialogs: BtwDialog[];
-  /** Access mode the active topic's child runs under. */
-  accessMode: ApprovalMode;
-  thinkingLevel: string;
   askDraft: string;
   followUpDraft: string;
   setAskDraft: (value: string) => void;
@@ -68,12 +59,8 @@ export interface BtwMode {
   submitAsk: () => void;
   /** Submit the side session's composer: a follow-up to the active topic. */
   submitFollowUp: (question: string, attachments?: Attachment[]) => void;
-  abort: () => void;
-  /** Re-target the side child's model (applies to the running turn). */
-  setModel: (provider: string, modelId: string) => void;
-  setThinkingLevel: (level: string) => void;
-  setAccessMode: (mode: ApprovalMode) => void;
-  respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => void;
+  /** Cancel the running turn, if any. Returns whether one was running. */
+  abort: () => boolean;
   /** Returns the session id to open, or null when promotion was refused. */
   promote: () => Promise<string | null>;
   removeTopic: (topicId: string) => void;
@@ -121,16 +108,6 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
    */
   const liveVerb = live?.activity || (runningTopicId ? PHASE_VERBS.sideQuestion : undefined);
 
-  /**
-   * Composer picks made before a topic exists. They are per-session UI state
-   * rather than props, because the form must show what the FIRST question will
-   * actually run with — the topic that would otherwise own these values has not
-   * been created yet.
-   */
-  const [pendingModel, setPendingModel] = useSessionState<BtwFirstQuestionPicks['model'] | null>('chat.btwModel', null);
-  const [pendingThinking, setPendingThinking] = useSessionState<string>('chat.btwThinking', 'auto');
-  const [pendingAccess, setPendingAccess] = useSessionState<ApprovalMode | null>('chat.btwAccess', null);
-
   const selectNewest = useCallback(
     (next: BtwState | null) => {
       if (!next) return;
@@ -151,27 +128,12 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     }
   });
 
-  /**
-   * What the next FIRST question will run with: the composer's picks until a
-   * topic exists, then that topic's own settings. Every setter below writes to
-   * the topic when there is one and to this pending slot when there is not —
-   * a pick that only reached the UI would silently not apply.
-   */
-  const firstQuestionPicks = useCallback(
-    (): BtwFirstQuestionPicks => ({
-      ...(pendingModel ? { model: pendingModel } : {}),
-      ...(pendingThinking && pendingThinking !== 'auto' ? { thinkingLevel: pendingThinking } : {}),
-      ...(pendingAccess ? { approvalMode: pendingAccess } : {}),
-    }),
-    [pendingModel, pendingThinking, pendingAccess],
-  );
-
   const submitAsk = useCallback(() => {
     const question = askDraft.trim();
     if (!question) return;
     setAskDraft('');
-    void session.ask(question, undefined, undefined, firstQuestionPicks()).then(selectNewest);
-  }, [askDraft, session, setAskDraft, selectNewest, firstQuestionPicks]);
+    void session.ask(question).then(selectNewest);
+  }, [askDraft, session, setAskDraft, selectNewest]);
 
   const submitFollowUp = useCallback(
     (question: string, attachments?: Attachment[]) => {
@@ -220,12 +182,6 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     liveMessages: live ? live.messages : [],
     liveVerb,
     error: session.error,
-    dialogs: session.state?.dialogs ?? [],
-    // Before a topic exists the composer's own picks are what the next question
-    // will run with, so they are what the controls must show — and after it,
-    // the topic's own settings (which the pick was written to).
-    accessMode: activeTopic?.approvalMode ?? pendingAccess ?? readAccessMode(appSettings),
-    thinkingLevel: activeTopic?.thinkingLevel ?? pendingThinking,
     askDraft,
     followUpDraft,
     setAskDraft,
@@ -239,29 +195,13 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     },
     submitAsk,
     submitFollowUp,
+    // Escape (and the composer's Stop) cancel the turn BEFORE leaving: omp's
+    // Escape handler cancels a running answer and only then closes the panel, so
+    // a stray keypress cannot abandon a question mid-flight.
     abort: () => {
-      if (runningTopicId) void session.abort(runningTopicId);
-    },
-    setModel: (provider: string, modelId: string) => {
-      if (!activeTopic) {
-        setPendingModel({ provider, id: modelId });
-        return;
-      }
-      void session.setModel(activeTopic.id, provider, modelId);
-    },
-    setThinkingLevel: (level: string) => {
-      setPendingThinking(level);
-      if (!activeTopic) return;
-      void session.setThinkingLevel(activeTopic.id, level);
-    },
-    setAccessMode: (mode: ApprovalMode) => {
-      setPendingAccess(mode);
-      if (!activeTopic) return;
-      void session.setAccessMode(activeTopic.id, mode);
-    },
-    respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => {
-      if (!activeTopic) return;
-      void session.respondToDialog(activeTopic.id, id, response);
+      if (!runningTopicId) return false;
+      void session.abort(runningTopicId);
+      return true;
     },
     promote,
     removeTopic,

package/src/client/hooks/chat/timeline/actions.ts

@@ -11,13 +11,15 @@
  * record — captured semantics are unchanged.
  */
 
-import { useCallback } from 'preact/hooks';
+import { useCallback, useMemo } from 'preact/hooks';
 import type { Dispatch, SetStateAction } from 'preact/compat';
 import type { Attachment, ChatMessageData, OmpAgentHandle, QueuedMessageModel } from '@/shared/types';
 import type { QueuedMessage } from '@/client/components/workspace/chat-timeline/QueueList';
 import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { applyComposerPick, consumeComposerPick, stashComposerPick, type DeferredModelStore } from '@/client/hooks/chat/timeline/deferred-model';
 import { dispatchBtwCommand } from '@/client/hooks/chat/btw/intercept';
+import { blockTuiOnlySend } from '@/client/hooks/chat/timeline/tui-only-guard';
+import { createQueueActions } from '@/client/hooks/chat/timeline/queue-actions';
 import { prepareQueuedAttachments } from '@/shared/lib/chat/attachments';
 
 export interface ChatTimelineActionsDeps {
@@ -76,14 +78,12 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
   const {
     inputValue,
     setInputValue,
-    setInputAttachments,
     isGenerating,
     isOmpSession,
     sessionId,
     appSettings,
     messageQueue,
     enqueueMessage,
-    removeMessage,
     executeSend,
     steerOmpAgent,
     ompAgent,
@@ -100,6 +100,10 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     setSearchParams,
   } = deps;
 
+  // The queue's two row actions take the same slice of this deps record, so
+  // they are built once per render from it rather than re-listing every field.
+  const queueActions = useMemo(() => createQueueActions(deps), [deps]);
+
   const handleSend = useCallback(async (attachments: Attachment[], options?: { steering?: boolean }) => {
     const textToSend = inputValue.trim();
     if (!textToSend && attachments.length === 0) return;
@@ -111,11 +115,21 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     // `/btw [question]` is the side-question entry point, not chat text: the
     // panel owns it (omp's `/btw` is TUI-only, so nothing downstream would
     // understand the token). A bare `/btw` only opens the panel's history.
+    //
+    // MUST run before the TUI-only guard below: `/btw` is in that table (omp
+    // implements it in the TUI only), so the guard would refuse the very
+    // command the chamber answers with a panel.
     if (dispatchBtwCommand(textToSend, attachments)) {
       setInputValue('');
       return;
     }
 
+    // A command omp only implements in its TUI (`/plan`, `/clear`, `/login`, …)
+    // would reach the model as literal text over RPC and burn a whole turn on
+    // an improvisation. Answer it here, before it is queued or steered, and
+    // keep the draft so the user can edit or retype it.
+    if (blockTuiOnlySend(textToSend, setLocalMessages)) return;
+
     if (isGenerating) {
       if (options?.steering) {
         // Explicit steering while a run is active.
@@ -161,37 +175,15 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
 
     setInputValue('');
     executeSend(textToSend, attachments);
-  }, [inputValue, isGenerating, executeSend, enqueueMessage, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef]);
+  }, [inputValue, isGenerating, executeSend, enqueueMessage, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef, setLocalMessages]);
 
   const handleEditQueueItem = useCallback((item: QueuedMessage) => {
-    // Lift the text into the composer and drop the row. If the user never
-    // re-submits, the delete (below) already removed it — the old flow had a
-    // dead window here where removing from the local list was the only edit.
-    setInputValue(item.text);
-    setInputAttachments(item.attachments);
-    removeMessage(item.id);
-  }, [removeMessage, setInputValue, setInputAttachments]);
+    queueActions.handleEditQueueItem(item);
+  }, [queueActions]);
 
   const handleSendNowQueueItem = useCallback(async (item: QueuedMessage) => {
-    // Explicit delivery also lifts the Stop hold (mock path).
-    stopHoldRef.current = false;
-    removeMessage(item.id);
-
-    if (isGenerating) {
-      if (isOmpSession) {
-        void steerOmpAgent(item.text, item.attachments);
-      } else {
-        if (abortControllerRef.current) {
-          abortControllerRef.current.abort();
-          abortControllerRef.current = null;
-        }
-        setGenerating(false);
-        setTimeout(() => executeSend(item.text, item.attachments, { model: item.model }), 0);
-      }
-    } else {
-      executeSend(item.text, item.attachments, { model: item.model });
-    }
-  }, [isGenerating, executeSend, removeMessage, isOmpSession, steerOmpAgent, abortControllerRef, setGenerating, stopHoldRef]);
+    await queueActions.handleSendNowQueueItem(item);
+  }, [queueActions]);
 
   const handleUndo = useCallback(async (msgId: string, content?: string): Promise<boolean> => {
     if (isGenerating) {

package/src/client/hooks/chat/timeline/queue-actions.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Queue-row actions for the chat timeline: editing a queued item back into the
+ * composer, and delivering one immediately.
+ *
+ * Split out of `actions.ts` so that hook keeps to the repo's per-file ceiling.
+ * Both handlers take the same deps record, and both are about ONE row of the
+ * follow-up queue rather than about the composer's own send path — which is the
+ * seam this file draws.
+ */
+
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { Attachment, QueuedMessageModel } from '@/shared/types';
+import type { QueuedMessage } from '@/client/components/workspace/chat-timeline/QueueList';
+
+export interface QueueActionsDeps {
+  setInputValue: (v: string) => void;
+  setInputAttachments: Dispatch<SetStateAction<Attachment[]>>;
+  removeMessage: (id: string) => void;
+  /** Armed by Stop; the queue auto-process holds off while it is set. */
+  stopHoldRef: { current: boolean };
+  isGenerating: boolean;
+  isOmpSession: boolean;
+  steerOmpAgent: (text: string, attachments: Attachment[]) => Promise<void>;
+  abortControllerRef: { current: AbortController | null };
+  setGenerating: (v: boolean) => void;
+  executeSend: (
+    text: string,
+    attachments: Attachment[],
+    options?: { model?: QueuedMessageModel | null },
+  ) => Promise<void>;
+}
+
+export interface QueueActions {
+  handleEditQueueItem: (item: QueuedMessage) => void;
+  handleSendNowQueueItem: (item: QueuedMessage) => Promise<void>;
+}
+
+export function createQueueActions(deps: QueueActionsDeps): QueueActions {
+  const {
+    setInputValue,
+    setInputAttachments,
+    removeMessage,
+    stopHoldRef,
+    isGenerating,
+    isOmpSession,
+    steerOmpAgent,
+    abortControllerRef,
+    setGenerating,
+    executeSend,
+  } = deps;
+  return {
+    /** Lift the row's text into the composer and drop the row. If the user
+     *  never re-submits, the delete already removed it — the old flow had a
+     *  dead window here where removing from the local list was the only edit. */
+    handleEditQueueItem: (item) => {
+      setInputValue(item.text);
+      setInputAttachments(item.attachments);
+      removeMessage(item.id);
+    },
+
+    /** Deliver one row now, ahead of the queue. Explicit delivery also lifts
+     *  the Stop hold, so the auto-process may resume after this run ends. */
+    handleSendNowQueueItem: async (item) => {
+      stopHoldRef.current = false;
+      removeMessage(item.id);
+
+      if (isGenerating) {
+        if (isOmpSession) {
+          void steerOmpAgent(item.text, item.attachments);
+        } else {
+          if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+          }
+          setGenerating(false);
+          setTimeout(() => executeSend(item.text, item.attachments, { model: item.model }), 0);
+        }
+      } else {
+        executeSend(item.text, item.attachments, { model: item.model });
+      }
+    },
+  };
+}

package/src/client/hooks/chat/timeline/send.ts

@@ -26,6 +26,7 @@ import {
   readTextAttachments,
 } from '@/shared/lib/chat/attachments';
 import { createMockStreamCallbacks } from '@/shared/lib/chat/timeline/stream-callbacks';
+import { blockTuiOnlySend } from '@/client/hooks/chat/timeline/tui-only-guard';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
 import { formatClock } from '@/shared/lib/format/time';
 
@@ -135,6 +136,12 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
     attachments: Attachment[],
     options?: { model?: QueuedMessageModel | null },
   ) => {
+    // Last gate before a prompt leaves the client. `handleSend` already refuses
+    // these, but `executeSend` is also reached by a retry of a stored turn, a
+    // queued item's "Send now", and `submitNewChat` — all of which can carry a
+    // command that was typed before the guard existed, or that arrived from the
+    // queue. Nothing has been rendered yet, so no rollback is needed.
+    if (blockTuiOnlySend(text, setLocalMessages)) return;
     // A queued delivery replays the snapshot the item was queued with; a plain
     // send keeps the session's live picks. 'auto' thinking leaves omp alone.
     const modelOverride = options?.model ?? null;
@@ -304,6 +311,6 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
         scrollToBottom,
       })
     );
-  }, [appSettings, folders, isOmpSession, ompAgent, selectedFolderId, sessionId, scrollToBottom, jumpToBottom, persistMessages, seedSession, pendingComposerModelRef, pendingThinkingLevelRef, deferredComposerPickRef, accessModeRef]);
+  }, [appSettings, folders, isOmpSession, ompAgent, selectedFolderId, sessionId, scrollToBottom, jumpToBottom, persistMessages, seedSession, pendingComposerModelRef, pendingThinkingLevelRef, deferredComposerPickRef, accessModeRef, setLocalMessages]);
   return { steerOmpAgent, executeSend };
 }

package/src/client/hooks/chat/timeline/tui-only-guard.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Refuse a slash command omp only implements in its own TUI, in the composer,
+ * before it can cost a turn.
+ *
+ * The guard exists because the RPC prompt path has no slash handling for these
+ * names: `session.prompt()` only expands file commands and prompt templates, so
+ * `/plan` arrives at the model as literal text and it improvises a whole turn
+ * around the string (measured: `/hotkeys` sent the model to read omp's own docs
+ * and run bash). The composer already knows the token, so it answers locally
+ * with the same notice row shape a real `command_output` frame produces — the
+ * user sees why nothing ran, and the model never sees the command.
+ *
+ * Every send path funnels through here: a fresh send, a steer, a retry of a
+ * stored turn, and a queued item's "send now". Queued auto-delivery is covered
+ * server-side (`blockedSlashPrompt` in the RPC dispatcher), because it never
+ * passes through this module.
+ */
+
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { ChatMessageData } from '@/shared/types';
+import { isTuiOnlySlashCommand, tuiOnlyCommandNotice } from '@/shared/lib/chat/composer/tui-only';
+
+/**
+ * Append the refusal as a notice row, the same shape `onCommandOutput` builds.
+ * Placed at the tail: no AI placeholder exists yet, so there is nothing to
+ * insert before.
+ */
+export function appendTuiOnlyNotice(
+  text: string,
+  setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>>,
+): void {
+  const row: ChatMessageData = {
+    id: `tui-only-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    role: 'ai',
+    content: '',
+    notice: tuiOnlyCommandNotice(text),
+  };
+  setLocalMessages(prev => (prev.some(m => m.notice === row.notice) ? prev : [...prev, row]));
+}
+
+/**
+ * Whether the draft is a TUI-only command and was answered locally. A true
+ * result means the caller must stop — nothing was sent, and the draft is left
+ * in the composer so the user can edit or retype it.
+ */
+export function blockTuiOnlySend(
+  text: string,
+  setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>>,
+): boolean {
+  if (!isTuiOnlySlashCommand(text)) return false;
+  appendTuiOnlyNotice(text, setLocalMessages);
+  return true;
+}

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