sh3-core 0.15.1 → 0.15.2

package/dist/shell-shard/InputLine.svelte

@@ -1,21 +1,22 @@
 <script lang="ts">
   import type { SessionClient } from './session-client.svelte';
+  import CommandLine from './CommandLine.svelte';
 
   interface Props {
     cwd: string;
+    /** When false, hide the cwd chip in front of the prompt. */
+    showCwd?: boolean;
     locked: boolean;                       // true while a process is running
     history: string[];                     // persisted history, newest last
     session: SessionClient;
     onSubmit: (line: string) => void;      // called with the raw entered line
   }
-  let { cwd, locked, history, session, onSubmit }: Props = $props();
+  let { cwd, showCwd = true, locked, history, session, onSubmit }: Props = $props();
 
   let draft = $state('');
   let historyIndex = $state<number | null>(null);  // null = live draft
   let savedDraft = $state('');                      // restored when user returns from history
 
-  let input: HTMLInputElement | null = $state(null);
-
   function submit() {
     if (locked) return;
     const line = draft;
@@ -74,6 +75,8 @@
       e.preventDefault();
       navHistoryDown();
     } else if (e.ctrlKey && e.key === 'c') {
+      // CommandLine has already filtered this case to no-selection, so the
+      // user is asking to clear the draft, not copy.
       e.preventDefault();
       draft = '';
       historyIndex = null;
@@ -83,52 +86,26 @@
       submit();
     }
   }
-
-  // Re-focus the input when the locked state flips to false
-  $effect(() => {
-    if (!locked && input) {
-      input.focus();
-    }
-  });
 </script>
 
-<div class="shell-input" class:locked>
-  <span class="shell-input-cwd">{cwd}</span>
-  <span class="shell-input-arrow">❯</span>
-  <input
-    bind:this={input}
+<div class="shell-input-row">
+  <CommandLine
     bind:value={draft}
-    type="text"
     disabled={locked}
+    name="shell-cmdline"
     onkeydown={onKeyDown}
-    spellcheck="false"
-    autocomplete="off"
-    autocapitalize="off"
-    class="shell-input-field"
-  />
+  >
+    {#snippet prefix()}
+      {#if showCwd}<span class="shell-input-cwd">{cwd}</span>{/if}
+      <span class="shell-input-arrow">❯</span>
+    {/snippet}
+  </CommandLine>
 </div>
 
 <style>
-  .shell-input {
-    display: flex;
-    gap: 8px;
-    padding: 4px 8px;
+  .shell-input-row {
     border-top: 1px solid var(--shell-border, #333);
-    font-family: var(--shell-font-mono, monospace);
   }
   .shell-input-cwd { color: var(--shell-fg-muted, #888); }
-  .shell-input-arrow { color: var(--shell-accent, #6cf); }
-  .shell-input-field {
-    padding: 0;
-    flex: 1 1 auto;
-    background: transparent;
-    border: 0;
-    outline: 0;
-    color: var(--shell-fg, #ddd);
-    font: inherit;
-  }
-  .shell-input.locked .shell-input-field {
-    opacity: 0.5;
-    cursor: default;
-  }
+  .shell-input-arrow { color: var(--shell-accent, #6cf); margin-left: 6px; }
 </style>

package/dist/shell-shard/InputLine.svelte.d.ts

@@ -1,6 +1,8 @@
 import type { SessionClient } from './session-client.svelte';
 interface Props {
     cwd: string;
+    /** When false, hide the cwd chip in front of the prompt. */
+    showCwd?: boolean;
     locked: boolean;
     history: string[];
     session: SessionClient;

package/dist/shell-shard/ScrollbackView.svelte

@@ -4,11 +4,13 @@
   import PromptEntry from './entries/PromptEntry.svelte';
   import StatusEntry from './entries/StatusEntry.svelte';
   import RichEntry from './entries/RichEntry.svelte';
+  import { lookupRichComponent } from './rich-registry';
 
   interface Props {
     scrollback: Scrollback;
+    showPromptCwd: boolean;
   }
-  let { scrollback }: Props = $props();
+  let { scrollback, showPromptCwd }: Props = $props();
 
   let container: HTMLDivElement | null = $state(null);
   let content: HTMLDivElement | null = $state(null);
@@ -48,11 +50,16 @@
       {#if entry.kind === 'text'}
         <TextEntry stream={entry.stream} chunks={entry.chunks} />
       {:else if entry.kind === 'prompt'}
-        <PromptEntry cwd={entry.cwd} line={entry.line} />
+        <PromptEntry cwd={showPromptCwd ? entry.cwd : ''} line={entry.line} />
       {:else if entry.kind === 'status'}
         <StatusEntry text={entry.text} level={entry.level} />
       {:else if entry.kind === 'rich'}
-        <RichEntry component={entry.component} componentProps={entry.props} />
+        {@const comp = entry.component ?? (entry.componentKey ? lookupRichComponent(entry.componentKey) : null)}
+        {#if comp}
+          <RichEntry component={comp} componentProps={entry.props} />
+        {:else}
+          <StatusEntry text={`<rich entry: ${entry.componentKey ?? 'unknown'} not registered>`} level="info" />
+        {/if}
       {/if}
     {/each}
   </div>

package/dist/shell-shard/ScrollbackView.svelte.d.ts

@@ -1,6 +1,7 @@
 import type { Scrollback } from './scrollback.svelte';
 interface Props {
     scrollback: Scrollback;
+    showPromptCwd: boolean;
 }
 declare const ScrollbackView: import("svelte").Component<Props, {}, "">;
 type ScrollbackView = ReturnType<typeof ScrollbackView>;

package/dist/shell-shard/Terminal.svelte

@@ -1,6 +1,9 @@
 <script lang="ts">
   import { onMount, onDestroy, untrack } from 'svelte';
-  import { Scrollback } from './scrollback.svelte';
+  import { ModeBuffer } from './mode-buffer.svelte';
+  import { BufferStore } from './buffer-store';
+  import { applyReplayEvents } from './replay';
+  import { shortenCwd } from './display-cwd';
   import ScrollbackView from './ScrollbackView.svelte';
   import InputLine from './InputLine.svelte';
   import { SessionClient } from './session-client.svelte';
@@ -33,7 +36,24 @@
   }
   let { shell, wsUrl, userId, role, contributions }: Props = $props();
 
-  const scrollback = new Scrollback();
+  // Per-mode buffer map. Each ModeBuffer bundles a Scrollback + history +
+  // locked flag and is materialized lazily on first switch into that mode.
+  // ScrollbackView, InputLine, and dispatch all read from the active mode's
+  // buffer; switching mode rebinds without losing the previous buffer.
+  // BufferStore hydrates from the workspace zone on first access of each
+  // mode's buffer, restoring scrollback + history across page reloads (SH8).
+  const bufferStore = untrack(() => new BufferStore());
+  const buffers = new Map<string, ModeBuffer>();
+  function getBuffer(modeId: string): ModeBuffer {
+    let b = buffers.get(modeId);
+    if (!b) {
+      b = new ModeBuffer(modeId);
+      bufferStore.hydrate(b);
+      buffers.set(modeId, b);
+    }
+    return b;
+  }
+
   const resolver = new VerbRegistry();
   const fs = new TenantFsClient();
 
@@ -65,6 +85,7 @@
       requiresRole: d.requiresRole,
       transport: 'custom',
       autoRelocate: d.autoRelocate ?? false,
+      showCwd: d.showCwd ?? false,
     };
   }
 
@@ -95,6 +116,39 @@
     }),
   );
 
+  // Active-mode buffer derivation. Reads `mode.id` reactively so that
+  // mode-switch flips ScrollbackView and InputLine bindings in lockstep.
+  const currentBuffer = $derived(getBuffer(mode.id));
+
+  // Mirror the server's per-mode history bundle into each ModeBuffer.
+  // The bundle arrives on attach and re-arrives on each reconnect. We
+  // only overwrite a buffer's history when the server has more lines
+  // than the client — preserves optimistic appends made between submits
+  // and the server's authoritative reply.
+  $effect(() => {
+    for (const [modeId, lines] of Object.entries(session.historyByMode)) {
+      const buf = getBuffer(modeId);
+      if (buf.history.length < lines.length) {
+        buf.history = [...lines];
+      }
+    }
+  });
+
+  // Persist the active buffer on every meaningful change. The flush is
+  // debounced 200ms inside BufferStore, so a stream of stdout chunks
+  // results in a single zone write per quiescent moment. The bash
+  // buffer additionally stamps session.lastSeq so a page reload can ask
+  // the server for replay events newer than the persisted snapshot.
+  $effect(() => {
+    void currentBuffer.scrollback.entries.length;
+    void currentBuffer.history.length;
+    if (currentBuffer.modeId === 'bash') {
+      bufferStore.flush(currentBuffer, session.lastSeq);
+    } else {
+      bufferStore.flush(currentBuffer);
+    }
+  });
+
   function setMode(id: string): void {
     const next = visibleModes.find((m) => m.id === id);
     if (!next) return;
@@ -104,9 +158,6 @@
     cancelDispatch();
     mode = next;
     writeLastMode(userId, id);
-    if (next.transport !== 'ws') {
-      scrollback.push({ kind: 'status', text: 'mode switch: reload to take effect for server-shell changes', level: 'info', ts: Date.now() });
-    }
   }
 
   // If the active mode disappears (shard unloaded), fall back to sh3 — or
@@ -118,7 +169,7 @@
         const lostId = mode.id;
         mode = fallback;
         writeLastMode(userId, fallback.id);
-        scrollback.push({
+        getBuffer(fallback.id).scrollback.push({
           kind: 'status',
           text: `mode '${lostId}' is no longer available — switched to '${fallback.id}'`,
           level: 'warn',
@@ -182,7 +233,7 @@
     mode: () => mode,
     role: () => role,
     resolver,
-    scrollback,
+    buffer: () => currentBuffer,
     session,
     shell: shellWithModes,
     fs,
@@ -191,8 +242,6 @@
     customMode: (id: string) => contributedModes.find((d) => d.id === id) ?? null,
   }));
 
-  let locked = $state(false);
-
   // ---------------------------------------------------------------------------
   // Auto-relocate: track the focused shard and update session.cwd when focus
   // changes to a shard whose documents directory exists. focusLocked and
@@ -266,18 +315,30 @@
   });
 
   function handleServerMessage(msg: ServerMessage) {
+    if (msg.t === 'replay') {
+      // Server's ring-buffer events between the last snapshot and now.
+      // Fold into the bash buffer using the same routing as live events.
+      applyReplayEvents(getBuffer('bash'), msg.events);
+      return;
+    }
     if (msg.t !== 'event') return;
     const e = msg.event;
+    // WS events always route to the bash buffer regardless of the active
+    // mode, so output keeps accumulating while the user is viewing sh3 or
+    // a custom mode. The bash buffer's locked flag tracks the running
+    // process; switching to a non-bash buffer naturally unlocks the input
+    // bar because each ModeBuffer carries its own locked state.
+    const bashBuf = getBuffer('bash');
     switch (e.kind) {
       case 'prompt':
-        scrollback.push({ kind: 'prompt', cwd: e.cwd, line: e.line, ts: e.ts });
-        locked = true;
+        bashBuf.scrollback.push({ kind: 'prompt', cwd: e.cwd, line: e.line, ts: e.ts });
+        bashBuf.locked = true;
         break;
       case 'stdout':
-        scrollback.push({ kind: 'text', stream: 'stdout', chunks: [e.data], ts: e.ts });
+        bashBuf.scrollback.push({ kind: 'text', stream: 'stdout', chunks: [e.data], ts: e.ts });
         break;
       case 'stderr':
-        scrollback.push({ kind: 'text', stream: 'stderr', chunks: [e.data], ts: e.ts });
+        bashBuf.scrollback.push({ kind: 'text', stream: 'stderr', chunks: [e.data], ts: e.ts });
         break;
       case 'exit':
         // Match real-shell UX: stay silent on clean exit. Only surface
@@ -285,7 +346,7 @@
         // processes (SIGINT, spawn errors, etc.). `code === null` with
         // no signal happens on clean close too — treat as success.
         if (e.signal || (e.code !== null && e.code !== 0)) {
-          scrollback.push({
+          bashBuf.scrollback.push({
             kind: 'status',
             text: e.signal
               ? `shell: process exited (${e.signal})`
@@ -294,10 +355,10 @@
             ts: e.ts,
           });
         }
-        locked = false;
+        bashBuf.locked = false;
         break;
       case 'status':
-        scrollback.push({ kind: 'status', text: e.text, level: e.level, ts: e.ts });
+        bashBuf.scrollback.push({ kind: 'status', text: e.text, level: e.level, ts: e.ts });
         break;
     }
   }
@@ -306,9 +367,18 @@
 
   onMount(() => {
     unsub = session.onMessage(handleServerMessage);
-    if (mode.transport === 'ws') {
-      session.connect();
+    // Pre-warm the bash buffer + seed lastSeq so the WS hello replays
+    // only events newer than the persisted snapshot. This closes the
+    // gap between last flush and reconnect on page reload.
+    getBuffer('bash');
+    const persistedSeq = bufferStore.readLastSeq('bash');
+    if (persistedSeq !== undefined) {
+      session.lastSeq = persistedSeq;
     }
+    // Always-connect: shell-shard is admin-gated, idle WS cost is
+    // negligible, and non-bash modes still need to log mode-tagged
+    // history server-side via history-log messages.
+    session.connect();
   });
 
   onDestroy(() => {
@@ -328,11 +398,12 @@
       'target-shard': { target: targetShard },
     }}
   />
-  <ScrollbackView {scrollback} />
+  <ScrollbackView showPromptCwd={mode.showCwd || false} scrollback={currentBuffer.scrollback} />
   <InputLine
-    cwd={session.cwd}
-    {locked}
-    history={session.history}
+    cwd={shortenCwd(session.cwd, session.tenantRoot)}
+    showCwd={mode.showCwd !== false}
+    locked={currentBuffer.locked}
+    history={currentBuffer.history}
     {session}
     onSubmit={dispatch}
   />

package/dist/shell-shard/buffer-store.d.ts

@@ -0,0 +1,15 @@
+import { ModeBuffer } from './mode-buffer.svelte';
+export declare class BufferStore {
+    private timers;
+    /** Restore a ModeBuffer's contents from the workspace zone, if any. */
+    hydrate(buffer: ModeBuffer): void;
+    /** Schedule a debounced write of the buffer's current state. */
+    flush(buffer: ModeBuffer, lastSeq?: number): void;
+    /** Force a synchronous write, bypassing debounce. Used on shard deactivate. */
+    forceFlush(buffer: ModeBuffer, lastSeq?: number): void;
+    /** Read the persisted lastSeq for a mode, if any. */
+    readLastSeq(modeId: string): number | undefined;
+    private write;
+    private toPersisted;
+    private toLive;
+}

package/dist/shell-shard/buffer-store.js

@@ -0,0 +1,124 @@
+/*
+ * BufferStore — serialize ModeBuffer state into the shell-shard's
+ * workspace zone with a 200ms debounce, cap at 500 entries per mode,
+ * and gracefully degrade non-serializable rich entries.
+ *
+ * Hydrate fills a fresh ModeBuffer from a previously-persisted snapshot.
+ * Flush schedules a debounced write of the buffer's current state. The
+ * bash buffer additionally carries a `lastSeq` cursor so the WS hello
+ * after reload can ask the server for replay events newer than the
+ * persisted snapshot.
+ */
+import { ModeBuffer } from './mode-buffer.svelte';
+import { readBuffer, writeBuffer, } from './buffer-zone-state.svelte';
+const PERSIST_CAP = 500;
+const DEBOUNCE_MS = 200;
+export class BufferStore {
+    constructor() {
+        this.timers = new Map();
+    }
+    /** Restore a ModeBuffer's contents from the workspace zone, if any. */
+    hydrate(buffer) {
+        const persisted = readBuffer(buffer.modeId);
+        if (!persisted)
+            return;
+        const live = [];
+        for (const p of persisted.entries) {
+            live.push(this.toLive(p));
+        }
+        // restore() splices in place AND bumps the module-scoped id counter past
+        // the restored max — without that bump, the next push() after a reload
+        // would mint an id colliding with a hydrated key and crash the keyed
+        // {#each} in ScrollbackView.
+        buffer.scrollback.restore(live);
+        buffer.history = [...persisted.history];
+    }
+    /** Schedule a debounced write of the buffer's current state. */
+    flush(buffer, lastSeq) {
+        const existing = this.timers.get(buffer.modeId);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.timers.delete(buffer.modeId);
+            this.write(buffer, lastSeq);
+        }, DEBOUNCE_MS);
+        this.timers.set(buffer.modeId, timer);
+    }
+    /** Force a synchronous write, bypassing debounce. Used on shard deactivate. */
+    forceFlush(buffer, lastSeq) {
+        const existing = this.timers.get(buffer.modeId);
+        if (existing) {
+            clearTimeout(existing);
+            this.timers.delete(buffer.modeId);
+        }
+        this.write(buffer, lastSeq);
+    }
+    /** Read the persisted lastSeq for a mode, if any. */
+    readLastSeq(modeId) {
+        var _a;
+        return (_a = readBuffer(modeId)) === null || _a === void 0 ? void 0 : _a.lastSeq;
+    }
+    write(buffer, lastSeq) {
+        const entries = buffer.scrollback.entries.slice(-PERSIST_CAP).map((e) => this.toPersisted(e));
+        const persisted = Object.assign({ entries, history: [...buffer.history] }, (lastSeq !== undefined ? { lastSeq } : {}));
+        writeBuffer(buffer.modeId, persisted);
+    }
+    toPersisted(e) {
+        if (e.kind === 'rich') {
+            const key = e.componentKey;
+            if (!key) {
+                return {
+                    id: e.id,
+                    kind: 'status',
+                    text: '<rich entry: not restorable (no componentKey)>',
+                    level: 'info',
+                    ts: e.ts,
+                };
+            }
+            try {
+                const propsJson = JSON.stringify(e.props);
+                return {
+                    id: e.id,
+                    kind: 'rich',
+                    componentKey: key,
+                    props: JSON.parse(propsJson),
+                    ts: e.ts,
+                };
+            }
+            catch (_a) {
+                return {
+                    id: e.id,
+                    kind: 'status',
+                    text: `<rich entry: ${key} not restorable>`,
+                    level: 'info',
+                    ts: e.ts,
+                };
+            }
+        }
+        if (e.kind === 'prompt')
+            return { id: e.id, kind: 'prompt', cwd: e.cwd, line: e.line, ts: e.ts };
+        if (e.kind === 'text')
+            return { id: e.id, kind: 'text', stream: e.stream, chunks: [...e.chunks], ts: e.ts };
+        return { id: e.id, kind: 'status', text: e.text, level: e.level, ts: e.ts };
+    }
+    toLive(p) {
+        if (p.kind === 'rich') {
+            // Component is recovered at render-time via lookupRichComponent in
+            // ScrollbackView. The live entry's `component` field is unused after
+            // hydration; pass an empty placeholder to satisfy the type.
+            return {
+                id: p.id,
+                kind: 'rich',
+                componentKey: p.componentKey,
+                component: undefined,
+                props: p.props,
+                ts: p.ts,
+            };
+        }
+        if (p.kind === 'prompt')
+            return { id: p.id, kind: 'prompt', cwd: p.cwd, line: p.line, ts: p.ts };
+        if (p.kind === 'text')
+            return { id: p.id, kind: 'text', stream: p.stream, chunks: [...p.chunks], ts: p.ts };
+        return { id: p.id, kind: 'status', text: p.text, level: p.level, ts: p.ts };
+    }
+}

package/dist/shell-shard/buffer-store.svelte.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/buffer-store.svelte.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { __resetForTests as resetZone, readBuffer, writeBuffer, } from './buffer-zone-state.svelte';
+import { BufferStore } from './buffer-store';
+import { ModeBuffer } from './mode-buffer.svelte';
+describe('BufferStore', () => {
+    beforeEach(() => {
+        resetZone();
+        vi.useFakeTimers();
+    });
+    it('hydrates an empty buffer when zone has nothing', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        store.hydrate(buf);
+        expect(buf.scrollback.entries).toEqual([]);
+        expect(buf.history).toEqual([]);
+    });
+    it('persists a serializable buffer after debounce', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'ls', ts: 1 });
+        buf.history.push('ls');
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(1);
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.history).toEqual(['ls']);
+    });
+    it('coalesces back-to-back flushes within debounce window', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'a', ts: 1 });
+        store.flush(buf);
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'b', ts: 2 });
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(2);
+    });
+    it('caps persisted entries at 500 (most recent)', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        for (let i = 0; i < 600; i++) {
+            buf.scrollback.push({ kind: 'prompt', cwd: '/', line: `cmd${i}`, ts: i });
+        }
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(500);
+        const first = persisted.entries[0];
+        expect(first.kind === 'prompt' && first.line).toBe('cmd100');
+    });
+    it('hydrates a previously persisted buffer', () => {
+        writeBuffer('sh3', {
+            entries: [{ id: 'e1', kind: 'prompt', cwd: '/', line: 'restored', ts: 1 }],
+            history: ['restored'],
+        });
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        store.hydrate(buf);
+        expect(buf.scrollback.entries).toHaveLength(1);
+        expect(buf.history).toEqual(['restored']);
+    });
+    it('hydrate prevents id collisions on subsequent pushes', () => {
+        // Persisted id well above any test-time mkId() counter so the bug
+        // would reproduce (duplicate keys) if hydrate did not bump the
+        // module-scoped id sequence past the restored max.
+        writeBuffer('sh3', {
+            entries: [{ id: 'e9999', kind: 'prompt', cwd: '/', line: 'restored', ts: 1 }],
+            history: [],
+        });
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        store.hydrate(buf);
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'next', ts: 2 });
+        const ids = buf.scrollback.entries.map((e) => e.id);
+        expect(new Set(ids).size).toBe(ids.length);
+        expect(Number(ids[1].slice(1))).toBeGreaterThan(9999);
+    });
+    it('non-serializable rich props degrade to status entry on persist', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        const circular = {};
+        circular.self = circular;
+        buf.scrollback.push({
+            kind: 'rich',
+            componentKey: 'apps-table',
+            component: {},
+            props: circular,
+            ts: 1,
+        });
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(1);
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries[0].kind).toBe('status');
+    });
+    it('persists lastSeq when provided', () => {
+        var _a;
+        const store = new BufferStore();
+        const buf = new ModeBuffer('bash');
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'ls', ts: 1 });
+        store.flush(buf, 42);
+        vi.advanceTimersByTime(200);
+        expect((_a = readBuffer('bash')) === null || _a === void 0 ? void 0 : _a.lastSeq).toBe(42);
+        expect(store.readLastSeq('bash')).toBe(42);
+    });
+});

package/dist/shell-shard/buffer-zone-state.svelte.d.ts

@@ -0,0 +1,38 @@
+import type { StateZones } from '../state/zones.svelte';
+export interface PersistedEntryBase {
+    id: string;
+    ts: number;
+}
+export type PersistedEntry = (PersistedEntryBase & {
+    kind: 'prompt';
+    cwd: string;
+    line: string;
+}) | (PersistedEntryBase & {
+    kind: 'text';
+    stream: 'stdout' | 'stderr';
+    chunks: string[];
+}) | (PersistedEntryBase & {
+    kind: 'rich';
+    componentKey: string;
+    props: unknown;
+}) | (PersistedEntryBase & {
+    kind: 'status';
+    text: string;
+    level: 'info' | 'warn' | 'error';
+});
+export interface PersistedBuffer {
+    entries: PersistedEntry[];
+    history: string[];
+    /** Only meaningful for the bash buffer — server's seq cursor at last flush. */
+    lastSeq?: number;
+}
+export interface ShellWorkspaceZoneSchema {
+    workspace: {
+        buffers: Record<string, PersistedBuffer>;
+    };
+}
+export declare function __bindZone(s: StateZones<ShellWorkspaceZoneSchema>): void;
+export declare function __unbindZone(): void;
+export declare function readBuffer(modeId: string): PersistedBuffer | undefined;
+export declare function writeBuffer(modeId: string, buf: PersistedBuffer): void;
+export declare function __resetForTests(): void;