dsh-tui-theme 0.6.0 → 0.6.1

package/lib/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAMlD,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAIjF,eAAO,MAAM,IAAI,kBAAY,CAAA;AAE7B,wDAAwD;AACxD,MAAM,MAAM,MAAM,GAAG,eAAe,CAAA;AAUpC,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAQrC,CAAA;AAkBF;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,MAAW,GAAG,IAAI,CA+I7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAMlD,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAIjF,eAAO,MAAM,IAAI,kBAAY,CAAA;AAE7B,wDAAwD;AACxD,MAAM,MAAM,MAAM,GAAG,eAAe,CAAA;AAUpC,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAAM,CAQrC,CAAA;AAkBF;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,MAAW,GAAG,IAAI,CAwJ7D"}

package/lib/types/index.js

@@ -101,8 +101,15 @@ export function apply(ctx, config = {}) {
         const firstConfirmation = !runtimeConfirmed;
         runtimeConfirmed = true;
         if (ownedStaticFiles.size > 0) {
-            removeBundledThemes([...ownedStaticFiles]);
+            // The write-then-remove cycle: this boot installed static fallbacks
+            // because the runtime seam was absent at apply time, then the seam
+            // arrived. Logged so the cycle's real-world frequency (and any future
+            // deferred-install optimization) can be measured from plugin logs.
+            const removed = removeBundledThemes([...ownedStaticFiles]);
             ownedStaticFiles.clear();
+            if (removed.length > 0) {
+                ctx.logger.info(`${PLUGIN_ID}: runtime themes confirmed; removed ${removed.length} static fallback file(s) installed earlier this boot`);
+            }
         }
         // Same-named static files win over runtime registrations. User-edited
         // files stay unmentioned; files byte-identical to the bundled copy add

package/lib/types/statusLine.d.ts

@@ -8,8 +8,16 @@
  *
  * The line belongs to the pink palettes: by default it only renders while a
  * pink theme is active (checked per render with the host's own theme
- * precedence, so a mid-session /theme switch takes effect on the next tick);
- * `statusScope: 'all-themes'` opts it into every other theme too.
+ * precedence, so a mid-session /theme switch takes effect within the pref
+ * cache TTL — at most one clock tick); `statusScope: 'all-themes'` opts it
+ * into every other theme too.
+ *
+ * Cost discipline: `session/event` is a token-level firehose (assistant/chunk
+ * et al.), but the rendered text only changes at turn boundaries and on the
+ * clock, so renders run on turn/start, turn/end, session/disposed, and the
+ * 15s tick — never per streamed chunk. The persisted-pref read behind the
+ * theme check is cached for the same tick length so a render is pure string
+ * building.
  * @module dsh-tui-theme/statusLine
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -29,6 +37,11 @@ export interface StatusOptions {
 }
 /** Fully-resolved status knobs. */
 export type EffectiveStatus = Required<StatusOptions>;
+/**
+ * @internal Drop the persisted-pref cache (verify.mjs only; not part of the
+ * plugin's behavioral contract). Production invalidation is the TTL.
+ */
+export declare function invalidateThemePrefCacheForTests(): void;
 /**
  * Start the status line inside the `tuiStatus` inject.
  *

package/lib/types/statusLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statusLine.d.ts","sourceRoot":"","sources":["../../src/statusLine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAQlD,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;AAEpD,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,+BAA+B;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,iEAAiE;IACjE,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,mCAAmC;AACnC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAA;AA+CrD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,GAAG,IAAI,CA8DvF"}
+{"version":3,"file":"statusLine.d.ts","sourceRoot":"","sources":["../../src/statusLine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAQlD,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;AAEpD,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,+BAA+B;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,iEAAiE;IACjE,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,mCAAmC;AACnC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAA;AAsBrD;;;GAGG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AA0CD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,GAAG,IAAI,CAqEvF"}

package/lib/types/statusLine.js

@@ -8,8 +8,16 @@
  *
  * The line belongs to the pink palettes: by default it only renders while a
  * pink theme is active (checked per render with the host's own theme
- * precedence, so a mid-session /theme switch takes effect on the next tick);
- * `statusScope: 'all-themes'` opts it into every other theme too.
+ * precedence, so a mid-session /theme switch takes effect within the pref
+ * cache TTL — at most one clock tick); `statusScope: 'all-themes'` opts it
+ * into every other theme too.
+ *
+ * Cost discipline: `session/event` is a token-level firehose (assistant/chunk
+ * et al.), but the rendered text only changes at turn boundaries and on the
+ * clock, so renders run on turn/start, turn/end, session/disposed, and the
+ * 15s tick — never per streamed chunk. The persisted-pref read behind the
+ * theme check is cached for the same tick length so a render is pure string
+ * building.
  * @module dsh-tui-theme/statusLine
  */
 import { join } from 'node:path';
@@ -21,13 +29,30 @@ const GLYPH = '✿';
 // the cordis plugin name — one literal would be three drift risks).
 const STATUS_KEY = PLUGIN_ID;
 const CLOCK_TICK_MS = 15_000;
+// The persisted-pref cache lives for one clock tick: a mid-session /theme
+// switch (the host rewrites theme.json alongside its own in-memory switch)
+// lands on the next turn boundary or tick, which is exactly the "next tick"
+// semantic the render path always promised. Without the cache every render
+// would pay a synchronous stat+read+JSON.parse on the host's UI thread.
+const THEME_PREF_TTL_MS = CLOCK_TICK_MS;
 /** The bundled themes this garnish belongs to. */
 const PINK_THEMES = new Set(['pink-night', 'pink-day', 'pink-ansi']);
+// `value: undefined` is a cached "no pref file / unparsable" answer, so the
+// common non-pink host (no theme.json at all) is one memory read per TTL
+// window instead of a failed syscall per render.
+let prefCache;
+/**
+ * @internal Drop the persisted-pref cache (verify.mjs only; not part of the
+ * plugin's behavioral contract). Production invalidation is the TTL.
+ */
+export function invalidateThemePrefCacheForTests() {
+    prefCache = undefined;
+}
 /**
  * The active theme name by the host's own precedence: DSH_TUI_THEME first,
- * then the persisted ~/.dsh-tui/theme.json pref. The unforced path (OSC 11
- * auto-detection) only ever resolves to a builtin palette, never a pink one,
- * so "no pref" means non-pink.
+ * then the persisted ~/.dsh-tui/theme.json pref (read through a one-tick
+ * cache). The unforced path (OSC 11 auto-detection) only ever resolves to a
+ * builtin palette, never a pink one, so "no pref" means non-pink.
  *
  * This deliberately mirrors the host's ThemeProvider resolution chain
  * (`components/design-system/ThemeProvider.tsx`, baseline dsh-TUI 0.9.3);
@@ -38,7 +63,11 @@ function activeThemeName(dataDir) {
     const env = process.env.DSH_TUI_THEME;
     if (env !== undefined && env !== '')
         return env;
-    return readThemePref(dataDir);
+    const now = Date.now();
+    if (prefCache === undefined || now - prefCache.at >= THEME_PREF_TTL_MS) {
+        prefCache = { at: now, value: readThemePref(dataDir) };
+    }
+    return prefCache.value;
 }
 function isPinkThemeActive(dataDir) {
     const name = activeThemeName(dataDir);
@@ -76,7 +105,8 @@ export function startStatusLine(ctx, getEffective) {
                 const parts = [];
                 // The line is pink garnish: off on other themes unless opted in.
                 // The theme check runs here (not once at startup) so a mid-session
-                // /theme switch lands on the next tick or session event.
+                // /theme switch lands within one pref-cache TTL — the next tick or
+                // turn boundary.
                 const themeAllows = eff.statusScope === 'all-themes' || isPinkThemeActive(dataDir);
                 if (eff.statusEnabled && themeAllows) {
                     if (eff.showGlyph)
@@ -102,10 +132,17 @@ export function startStatusLine(ctx, getEffective) {
         };
         statusCtx.on('session/event', (session, event) => {
             current = session;
-            if (event?.type === 'turn/end') {
+            const type = event?.type;
+            if (type === 'turn/end') {
                 turns.set(session, (turns.get(session) ?? 0) + 1);
             }
-            render();
+            // The firehose filter: session/event carries every token-level chunk,
+            // tool call, and step bracket, but the rendered text only changes at
+            // turn boundaries (the count) or on the clock timer. turn/start is a
+            // session's first live event, so a session switch repaints immediately
+            // (the new session's count is 0 until its first turn ends).
+            if (type === 'turn/start' || type === 'turn/end')
+                render();
         });
         statusCtx.on('session/disposed', session => {
             turns.delete(session);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tui-theme",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Sakura-pink themes for dsh-TUI with optional cached background follow (pink-day/pink-night), a blossom status line, and a /settings section. No shortcuts, no commands.",
   "type": "module",
   "main": "lib/types/index.js",

package/scripts/verify.mjs

@@ -45,7 +45,7 @@ const sandboxThemes = join(sandboxHome, '.dsh-tui', 'themes')
 
 const { name, apply } = await import('../lib/types/index.js')
 const { installBundledThemes, readBundledThemes, findShadowedBundledThemes } = await import('../lib/types/themeAssets.js')
-const { startStatusLine } = await import('../lib/types/statusLine.js')
+const { startStatusLine, invalidateThemePrefCacheForTests } = await import('../lib/types/statusLine.js')
 const { setToastRetryDelaysForTests } = await import('../lib/types/toast.js')
 const {
   themeForBackground,
@@ -399,8 +399,10 @@ const emit = (record, event, ...args) => {
   emit(record, 'session/event', session, { type: 'turn/end' })
   assert.match(statusCalls.at(-1)[1], /^✿ · \d{2}:\d{2} · 1✦$/)
 
-  // Non-pink theme active → hidden by default.
+  // Non-pink theme active → hidden by default. The pref cache is dropped so
+  // the rewrite is visible immediately (production invalidation is the TTL).
   writeFileSync(themePrefPath, JSON.stringify({ theme: 'dark' }, null, 2))
+  invalidateThemePrefCacheForTests()
   emit(record, 'session/event', session, { type: 'turn/end' })
   assert.equal(statusCalls.at(-1)[1], undefined)
 
@@ -837,5 +839,83 @@ const emit = (record, event, ...args) => {
   console.log('✓ toast feedback: follow/self-heal/shadow hints delivered, dropped and seam-less sends retried, legacy hosts silent and bounded')
 }
 
+// ── 14. hot path: the token firehose must not reach render or the disk ──────
+{
+  const themePrefPath = join(sandboxHome, '.dsh-tui', 'theme.json')
+  writeFileSync(themePrefPath, JSON.stringify({ theme: 'pink-night' }, null, 2))
+  // Earlier scenarios ran status activations against a different pref; drop
+  // their cached answer so this scenario starts from the fresh sandbox state.
+  invalidateThemePrefCacheForTests()
+  const statusCalls = []
+  const settingsRecord = { registerCalls: [], watchers: [] }
+  const { ctx, record } = makeStubCtx({
+    status: fakeStatus(statusCalls),
+    settingsService: fakeSettingsService(settingsRecord, {}),
+  })
+  await applyAndSettle(ctx)
+  const session = { id: 'h1' }
+  emit(record, 'session/event', session, { type: 'turn/end' })
+  const baselineCalls = statusCalls.length
+  assert.match(statusCalls.at(-1)[1], /1✦$/)
+
+  // A firehose burst (streaming chunks, tool traffic, step brackets) updates
+  // the tracked session but must render nothing and never touch the disk.
+  const originalRead = builtinFs.readFileSync
+  let prefReads = 0
+  try {
+    builtinFs.readFileSync = (path, ...rest) => {
+      if (String(path) === themePrefPath) prefReads += 1
+      return originalRead(path, ...rest)
+    }
+    syncBuiltinESMExports()
+    for (let index = 0; index < 50; index += 1) {
+      emit(record, 'session/event', session, {
+        type: 'assistant/chunk',
+        turn: 1,
+        step: 1,
+        chunk: { type: 'text', text: 'x' },
+      })
+    }
+    emit(record, 'session/event', session, {
+      type: 'tool/call', turn: 1, step: 1, callId: 'c1', name: 'tool', arguments: '{}',
+    })
+    emit(record, 'session/event', session, { type: 'step/end', turn: 1, step: 1 })
+    emit(record, 'session/event', session, { type: 'todo/write', todos: [] })
+    assert.equal(statusCalls.length, baselineCalls, 'firehose events render nothing')
+    assert.equal(prefReads, 0, 'firehose events never read the theme pref')
+
+    // A turn boundary renders — served by the warm pref cache (no disk hit
+    // within the TTL), so even boundary renders stay off the filesystem.
+    emit(record, 'session/event', session, { type: 'turn/end' })
+    assert.equal(statusCalls.length, baselineCalls + 1, 'a turn boundary renders')
+    assert.equal(prefReads, 0, 'the warm cache serves the boundary render')
+
+    // A session switch repaints at its first turn/start with a fresh count.
+    const nextSession = { id: 'h2' }
+    emit(record, 'session/event', nextSession, { type: 'turn/start' })
+    assert.equal(statusCalls.length, baselineCalls + 2)
+    assert.match(statusCalls.at(-1)[1], /0✦$/)
+    assert.equal(prefReads, 0)
+
+    // Inside the TTL a pref rewrite is not yet visible and costs no read…
+    writeFileSync(themePrefPath, JSON.stringify({ theme: 'dark' }, null, 2))
+    emit(record, 'session/event', nextSession, { type: 'turn/end' })
+    assert.equal(statusCalls.length, baselineCalls + 3)
+    assert.match(statusCalls.at(-1)[1], /1✦$/, 'the cached pink pref keeps the line visible')
+    assert.equal(prefReads, 0, 'the TTL serves the stale-but-pink answer without I/O')
+
+    // …after invalidation (TTL expiry in production) the next render re-reads.
+    invalidateThemePrefCacheForTests()
+    emit(record, 'session/event', nextSession, { type: 'turn/end' })
+    assert.equal(prefReads, 1, 'invalidation re-reads the pref exactly once')
+    assert.equal(statusCalls.at(-1)[1], undefined, 'the non-pink pref hides the line')
+  } finally {
+    builtinFs.readFileSync = originalRead
+    syncBuiltinESMExports()
+    invalidateThemePrefCacheForTests()
+  }
+  console.log('✓ hot path: firehose events render nothing and never read the pref; boundaries use the cache')
+}
+
 console.log('\nAll plugin verifications passed.')
 console.log(`(sandbox used: ${sandboxHome} — the real home was never touched)`)