sh3-core 0.15.1 → 0.15.2

package/dist/shell-shard/replay.svelte.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { applyReplayEvents } from './replay';
+import { ModeBuffer } from './mode-buffer.svelte';
+describe('applyReplayEvents', () => {
+    it('folds events into a fresh bash buffer like live events', () => {
+        const buf = new ModeBuffer('bash');
+        const events = [
+            { seq: 5, kind: 'prompt', line: 'ls', cwd: '/', ts: 100 },
+            { seq: 6, kind: 'stdout', data: 'a\nb\n', ts: 101 },
+            { seq: 7, kind: 'exit', code: 0, signal: null, ts: 102 },
+        ];
+        applyReplayEvents(buf, events);
+        // prompt + coalesced text — exit code 0 is silent (matches Terminal.svelte UX).
+        expect(buf.scrollback.entries).toHaveLength(2);
+        expect(buf.locked).toBe(false);
+    });
+    it('locks the buffer if replay ends with a prompt without exit', () => {
+        const buf = new ModeBuffer('bash');
+        const events = [
+            { seq: 10, kind: 'prompt', line: 'sleep 5', cwd: '/', ts: 200 },
+        ];
+        applyReplayEvents(buf, events);
+        expect(buf.locked).toBe(true);
+    });
+    it('emits a status entry on non-zero exit', () => {
+        const buf = new ModeBuffer('bash');
+        const events = [
+            { seq: 1, kind: 'prompt', line: 'false', cwd: '/', ts: 1 },
+            { seq: 2, kind: 'exit', code: 1, signal: null, ts: 2 },
+        ];
+        applyReplayEvents(buf, events);
+        const last = buf.scrollback.entries[buf.scrollback.entries.length - 1];
+        expect(last.kind).toBe('status');
+        if (last.kind === 'status')
+            expect(last.text).toMatch(/exited \(1\)/);
+    });
+    it('routes stderr to a stderr text entry', () => {
+        const buf = new ModeBuffer('bash');
+        applyReplayEvents(buf, [
+            { seq: 1, kind: 'stderr', data: 'oops\n', ts: 1 },
+        ]);
+        const e = buf.scrollback.entries[0];
+        expect(e.kind).toBe('text');
+        if (e.kind === 'text')
+            expect(e.stream).toBe('stderr');
+    });
+});

package/dist/shell-shard/rich-registry.d.ts

@@ -0,0 +1,5 @@
+import type { Component } from 'svelte';
+export declare function registerRichComponent(key: string, component: Component<any>): void;
+export declare function lookupRichComponent(key: string): Component<any> | null;
+/** Test-only seam. Do not call from production code. */
+export declare function __resetRichRegistryForTests(): void;

package/dist/shell-shard/rich-registry.js

@@ -0,0 +1,25 @@
+/*
+ * Stable string-keyed registry mapping a componentKey to a Svelte
+ * component. Used by ScrollbackView (live render) and BufferStore
+ * (rehydrate persisted rich entries).
+ *
+ * Each rich-emitting verb registers its component once at module load.
+ * Keys must be globally unique within the shell-shard namespace.
+ */
+const components = new Map();
+export function registerRichComponent(key, component) {
+    const existing = components.get(key);
+    if (existing && existing !== component) {
+        console.warn(`[shell-shard/rich-registry] duplicate registration for key "${key}" — keeping first`);
+        return;
+    }
+    components.set(key, component);
+}
+export function lookupRichComponent(key) {
+    var _a;
+    return (_a = components.get(key)) !== null && _a !== void 0 ? _a : null;
+}
+/** Test-only seam. Do not call from production code. */
+export function __resetRichRegistryForTests() {
+    components.clear();
+}

package/dist/shell-shard/rich-registry.test.d.ts

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

package/dist/shell-shard/rich-registry.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { registerRichComponent, lookupRichComponent, __resetRichRegistryForTests, } from './rich-registry';
+const FakeComp = {};
+const OtherComp = {};
+describe('rich-registry', () => {
+    beforeEach(() => {
+        __resetRichRegistryForTests();
+    });
+    it('returns null for unknown keys', () => {
+        expect(lookupRichComponent('nope')).toBe(null);
+    });
+    it('roundtrips a registered key', () => {
+        registerRichComponent('test', FakeComp);
+        expect(lookupRichComponent('test')).toBe(FakeComp);
+    });
+    it('warns and ignores duplicate registrations of a different component', () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        registerRichComponent('dup', FakeComp);
+        registerRichComponent('dup', OtherComp);
+        expect(lookupRichComponent('dup')).toBe(FakeComp);
+        expect(warn).toHaveBeenCalledOnce();
+        warn.mockRestore();
+    });
+    it('idempotent registration of the same component is silent', () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        registerRichComponent('idem', FakeComp);
+        registerRichComponent('idem', FakeComp);
+        expect(warn).not.toHaveBeenCalled();
+        warn.mockRestore();
+    });
+});

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

@@ -15,6 +15,7 @@ export type ScrollbackEntry = {
 } | {
     kind: 'rich';
     id: string;
+    componentKey?: string;
     component: RichComponent;
     props: Record<string, unknown>;
     ts: number;
@@ -32,5 +33,6 @@ export declare class Scrollback {
     constructor(cap?: number);
     push(entry: DistributiveOmit<ScrollbackEntry, 'id'>): void;
     clear(): void;
+    restore(entries: ScrollbackEntry[]): void;
 }
 export {};

package/dist/shell-shard/scrollback.svelte.js

@@ -16,6 +16,14 @@ let nextId = 0;
 function mkId() {
     return `e${++nextId}`;
 }
+// Parses the numeric suffix of an id minted by mkId (`e<n>`). Returns NaN
+// for any other shape so restore() can ignore it without throwing.
+function parseIdNumber(id) {
+    if (id.length < 2 || id.charCodeAt(0) !== 101 /* 'e' */)
+        return NaN;
+    const n = Number(id.slice(1));
+    return Number.isInteger(n) ? n : NaN;
+}
 export class Scrollback {
     constructor(cap = DEFAULT_CAP) {
         this.entries = $state([]);
@@ -40,4 +48,19 @@ export class Scrollback {
     clear() {
         this.entries.length = 0;
     }
+    // Replace entries from a persisted snapshot. Splices in place to keep the
+    // $state proxy identity stable, and bumps the module-scoped id counter
+    // past any restored numeric id so subsequent push()es never collide with
+    // hydrated keys (which would crash Svelte's keyed {#each}).
+    restore(entries) {
+        let max = 0;
+        for (const e of entries) {
+            const n = parseIdNumber(e.id);
+            if (Number.isFinite(n) && n > max)
+                max = n;
+        }
+        if (max > nextId)
+            nextId = max;
+        this.entries.splice(0, this.entries.length, ...entries);
+    }
 }

package/dist/shell-shard/scrollback.svelte.test.d.ts

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

package/dist/shell-shard/scrollback.svelte.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { Scrollback } from './scrollback.svelte';
+const FakeComp = {};
+describe('Scrollback rich entry', () => {
+    it('stores componentKey alongside component for persistence', () => {
+        const sb = new Scrollback();
+        sb.push({
+            kind: 'rich',
+            componentKey: 'test-table',
+            component: FakeComp,
+            props: { foo: 1 },
+            ts: 0,
+        });
+        const entry = sb.entries[0];
+        expect(entry.kind).toBe('rich');
+        if (entry.kind === 'rich') {
+            expect(entry.componentKey).toBe('test-table');
+            expect(entry.component).toStrictEqual(FakeComp);
+            expect(entry.props).toEqual({ foo: 1 });
+        }
+    });
+});
+describe('Scrollback.restore', () => {
+    it('replaces entries and bumps id counter past max persisted id', () => {
+        const sb = new Scrollback();
+        sb.restore([
+            { id: 'e500', kind: 'prompt', cwd: '/', line: 'a', ts: 0 },
+            { id: 'e501', kind: 'prompt', cwd: '/', line: 'b', ts: 1 },
+        ]);
+        expect(sb.entries).toHaveLength(2);
+        sb.push({ kind: 'prompt', cwd: '/', line: 'c', ts: 2 });
+        expect(sb.entries).toHaveLength(3);
+        const ids = sb.entries.map((e) => e.id);
+        expect(new Set(ids).size).toBe(3);
+        const minted = ids[2];
+        expect(Number(minted.slice(1))).toBeGreaterThan(501);
+    });
+    it('preserves $state identity by mutating in place', () => {
+        const sb = new Scrollback();
+        const ref = sb.entries;
+        sb.restore([{ id: 'eX', kind: 'prompt', cwd: '/', line: 'a', ts: 0 }]);
+        expect(sb.entries).toBe(ref);
+    });
+    it('tolerates non-numeric ids without throwing', () => {
+        const sb = new Scrollback();
+        sb.restore([{ id: 'foo', kind: 'prompt', cwd: '/', line: 'a', ts: 0 }]);
+        sb.push({ kind: 'prompt', cwd: '/', line: 'b', ts: 1 });
+        expect(sb.entries).toHaveLength(2);
+        expect(new Set(sb.entries.map((e) => e.id)).size).toBe(2);
+    });
+});

package/dist/shell-shard/session-client.svelte.d.ts

@@ -5,13 +5,29 @@ export declare class SessionClient {
     private ws;
     private handlers;
     private pendingHistoryLogs;
-    private lastSeq;
     private backoffIndex;
     private closed;
     connected: boolean;
     cwd: string;
+    /**
+     * Per-user shell tenant root, fixed for the session's lifetime. Used by
+     * the input line to render the cwd relative to this prefix (e.g., `~`).
+     * Populated from the server's welcome message.
+     */
+    tenantRoot: string;
     env: Record<string, string>;
-    history: string[];
+    /**
+     * Per-mode history bundle hydrated from the server's history-bundle reply.
+     * Each entry is the persisted history for that mode id. Terminal.svelte
+     * mirrors these slots into the corresponding ModeBuffer.history.
+     */
+    historyByMode: Record<string, string[]>;
+    /**
+     * Latest server-event seq the client has observed. Public so the boot
+     * path can pre-seed it from a persisted bash buffer snapshot before
+     * calling connect(); the WS hello then uses it as a replay cursor.
+     */
+    lastSeq: number;
     constructor(url: string);
     connect(): void;
     private scheduleReconnect;

package/dist/shell-shard/session-client.svelte.js

@@ -21,13 +21,29 @@ export class SessionClient {
         this.ws = null;
         this.handlers = new Set();
         this.pendingHistoryLogs = [];
-        this.lastSeq = 0;
         this.backoffIndex = 0;
         this.closed = false;
         this.connected = $state(false);
         this.cwd = $state('');
+        /**
+         * Per-user shell tenant root, fixed for the session's lifetime. Used by
+         * the input line to render the cwd relative to this prefix (e.g., `~`).
+         * Populated from the server's welcome message.
+         */
+        this.tenantRoot = $state('');
         this.env = $state({});
-        this.history = $state([]);
+        /**
+         * Per-mode history bundle hydrated from the server's history-bundle reply.
+         * Each entry is the persisted history for that mode id. Terminal.svelte
+         * mirrors these slots into the corresponding ModeBuffer.history.
+         */
+        this.historyByMode = $state({});
+        /**
+         * Latest server-event seq the client has observed. Public so the boot
+         * path can pre-seed it from a persisted bash buffer snapshot before
+         * calling connect(); the WS hello then uses it as a replay cursor.
+         */
+        this.lastSeq = $state(0);
     }
     connect() {
         if (this.closed)
@@ -66,14 +82,15 @@ export class SessionClient {
             }
             if (msg.t === 'welcome') {
                 this.cwd = msg.cwd;
+                this.tenantRoot = msg.tenantRoot;
                 this.env = msg.env;
                 this.lastSeq = msg.seq;
             }
             if (msg.t === 'cwd') {
                 this.cwd = msg.cwd;
             }
-            if (msg.t === 'history') {
-                this.history = msg.lines;
+            if (msg.t === 'history-bundle') {
+                this.historyByMode = msg.byMode;
             }
             for (const h of this.handlers)
                 h(msg);

package/dist/shell-shard/shellApi.d.ts

@@ -1,3 +1,4 @@
 import type { ShellApi } from './registry';
-export declare function makeShellApiHeadless(): ShellApi;
+import type { ZoneManager } from '../state/types';
+export declare function makeShellApiHeadless(zones?: ZoneManager): ShellApi;
 export declare function makeShellApiForTest(): ShellApi;

package/dist/shell-shard/shellApi.js

@@ -15,6 +15,7 @@ import { registeredShards, listStandaloneViews } from '../shards/activate.svelte
 import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIntoActiveLayout, locateSlot as locateSlotInActiveLayout, } from '../layout/inspection';
 import { floatManager } from '../overlays/float';
 import { getUser, isAdmin } from '../auth/index';
+const KNOWN_ZONES = ['ephemeral', 'session', 'workspace', 'user'];
 function collectTabEntries(node) {
     if (node.type === 'tabs') {
         return node.tabs.filter((t) => t.viewId !== null);
@@ -27,7 +28,7 @@ function collectTabEntries(node) {
     }
     return [];
 }
-export function makeShellApiHeadless() {
+export function makeShellApiHeadless(zones) {
     return {
         listApps() {
             return listRegisteredApps().map((m) => ({ id: m.id, label: m.label }));
@@ -123,8 +124,35 @@ export function makeShellApiHeadless() {
             void closeTab(slotId);
             return { ok: true };
         },
-        listZones(_shardId) { return []; },
-        readZone(_shardId, _zoneName) { return null; },
+        listZones(shardId) {
+            if (!zones)
+                return [];
+            const byShard = new Map();
+            for (const zone of KNOWN_ZONES) {
+                for (const id of zones.list(zone)) {
+                    if (shardId && id !== shardId)
+                        continue;
+                    let set = byShard.get(id);
+                    if (!set) {
+                        set = new Set();
+                        byShard.set(id, set);
+                    }
+                    set.add(zone);
+                }
+            }
+            return Array.from(byShard.entries()).map(([id, set]) => ({
+                shardId: id,
+                zones: Array.from(set),
+            }));
+        },
+        readZone(shardId, zoneName) {
+            var _a;
+            if (!zones)
+                return null;
+            if (!KNOWN_ZONES.includes(zoneName))
+                return null;
+            return (_a = zones.peek(zoneName, shardId)) !== null && _a !== void 0 ? _a : null;
+        },
         whoAmI() {
             var _a;
             const user = getUser();

package/dist/shell-shard/shellApi.svelte.test.d.ts

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

package/dist/shell-shard/shellApi.svelte.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { makeShellApiHeadless } from './shellApi';
+function makeMockZoneManager() {
+    const data = {
+        ephemeral: {},
+        session: { 'shard-a': { foo: 1 } },
+        workspace: { 'shard-a': { bar: 2 }, 'shard-b': { baz: 3 } },
+        user: { 'shard-b': { theme: 'dark' } },
+    };
+    return {
+        list: (zone) => Object.keys(data[zone]),
+        peek: (zone, shardId) => data[zone][shardId],
+        clear: () => { },
+        clearAll: () => { },
+    };
+}
+describe('shellApi listZones', () => {
+    it('returns empty when no ZoneManager provided (stub mode)', () => {
+        const api = makeShellApiHeadless();
+        expect(api.listZones()).toEqual([]);
+    });
+    it('returns one row per shard with the zones it has data in', () => {
+        var _a, _b;
+        const api = makeShellApiHeadless(makeMockZoneManager());
+        const rows = api.listZones();
+        const byShard = new Map(rows.map((r) => [r.shardId, r.zones]));
+        expect((_a = byShard.get('shard-a')) === null || _a === void 0 ? void 0 : _a.sort()).toEqual(['session', 'workspace']);
+        expect((_b = byShard.get('shard-b')) === null || _b === void 0 ? void 0 : _b.sort()).toEqual(['user', 'workspace']);
+    });
+    it('filters by shardId when provided', () => {
+        const api = makeShellApiHeadless(makeMockZoneManager());
+        const rows = api.listZones('shard-a');
+        expect(rows).toHaveLength(1);
+        expect(rows[0].shardId).toBe('shard-a');
+        expect(rows[0].zones.sort()).toEqual(['session', 'workspace']);
+    });
+    it('returns empty array for unknown shardId', () => {
+        const api = makeShellApiHeadless(makeMockZoneManager());
+        expect(api.listZones('not-a-shard')).toEqual([]);
+    });
+});
+describe('shellApi readZone', () => {
+    it('returns null when no ZoneManager provided', () => {
+        const api = makeShellApiHeadless();
+        expect(api.readZone('shard-a', 'workspace')).toBe(null);
+    });
+    it('returns peeked value via ZoneManager', () => {
+        const api = makeShellApiHeadless(makeMockZoneManager());
+        expect(api.readZone('shard-a', 'workspace')).toEqual({ bar: 2 });
+    });
+    it('returns null for unknown zone name', () => {
+        const api = makeShellApiHeadless(makeMockZoneManager());
+        expect(api.readZone('shard-a', 'bogus')).toBe(null);
+    });
+    it('returns null for missing shard entry', () => {
+        const api = makeShellApiHeadless(makeMockZoneManager());
+        expect(api.readZone('not-a-shard', 'workspace')).toBe(null);
+    });
+});

package/dist/shell-shard/shellShard.svelte.js

@@ -24,12 +24,19 @@ import { makeShellApiHeadless } from './shellApi';
 import { focusView } from '../layout/inspection';
 import { floatManager } from '../overlays/float';
 import { getUser, isAdmin } from '../auth/index';
+import { __bindZone, __unbindZone } from './buffer-zone-state.svelte';
 export { makeShellApiHeadless, makeShellApiForTest } from './shellApi';
 export const shellShard = {
     manifest,
     activate(ctx) {
         registerV1Verbs(ctx);
-        const shell = makeShellApiHeadless();
+        const shell = makeShellApiHeadless(ctx.zones);
+        // Bind the shell-shard's workspace zone — backs scrollback persistence
+        // (SH8). BufferStore reads/writes through this proxy.
+        const zone = ctx.state({
+            workspace: { buffers: {} },
+        });
+        __bindZone(zone);
         // The AZERTY `²` key (top-left on FR keyboards, below Escape) opens the
         // terminal view — focusing it if already mounted, floating it otherwise.
         // Migrated from Shell.svelte's inline keydown handler as proof-of-concept
@@ -72,4 +79,7 @@ export const shellShard = {
     autostart() {
         // Intentionally empty — same pattern as __sh3core__.
     },
+    deactivate() {
+        __unbindZone();
+    },
 };

package/dist/shell-shard/terminal-dispatch.test.js

@@ -7,6 +7,8 @@ function scaffold(modeId) {
         ? { id: 'bash', label: 'Bash', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }
         : { id: 'sh3', label: 'SH3', transport: 'none', autoRelocate: true };
     const scrollback = { push: (e) => pushed.push(e) };
+    const history = [];
+    const buffer = { scrollback, history };
     const session = {
         history: { push: vi.fn() },
         send: (m) => sent.push(m),
@@ -28,7 +30,7 @@ function scaffold(modeId) {
         mode: () => mode,
         role: () => (modeId === 'bash' ? 'admin' : 'user'),
         resolver,
-        scrollback,
+        buffer: () => buffer,
         session,
         shell,
         fs,

package/dist/shell-shard/verbs/apps.js

@@ -1,5 +1,10 @@
 import AppsTable from '../rich/AppsTable.svelte';
 import AppCard from '../rich/AppCard.svelte';
+import { registerRichComponent } from '../rich-registry';
+const APPS_TABLE_KEY = 'apps-table';
+const APP_CARD_KEY = 'app-card';
+registerRichComponent(APPS_TABLE_KEY, AppsTable);
+registerRichComponent(APP_CARD_KEY, AppCard);
 export const appsVerb = {
     name: 'apps',
     summary: 'List installed apps. Click a row to launch.',
@@ -8,6 +13,7 @@ export const appsVerb = {
         const apps = ctx.shell.listApps();
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: APPS_TABLE_KEY,
             component: AppsTable,
             props: {
                 data: {
@@ -44,6 +50,7 @@ export const appVerb = {
         }
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: APP_CARD_KEY,
             component: AppCard,
             props: { data: { id: active.id, label: active.label, shards: [] } },
             ts: Date.now(),

package/dist/shell-shard/verbs/env.js

@@ -1,4 +1,7 @@
 import EnvTable from '../rich/EnvTable.svelte';
+import { registerRichComponent } from '../rich-registry';
+const ENV_TABLE_KEY = 'env-table';
+registerRichComponent(ENV_TABLE_KEY, EnvTable);
 export const envVerb = {
     name: 'env',
     summary: 'Show the session environment.',
@@ -6,6 +9,7 @@ export const envVerb = {
         const env = ctx.session.env;
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: ENV_TABLE_KEY,
             component: EnvTable,
             props: { data: { env } },
             ts: Date.now(),

package/dist/shell-shard/verbs/help.js

@@ -1,5 +1,8 @@
 import { listVerbs } from '../../shards/registry';
 import HelpTable from '../rich/HelpTable.svelte';
+import { registerRichComponent } from '../rich-registry';
+const HELP_TABLE_KEY = 'help-table';
+registerRichComponent(HELP_TABLE_KEY, HelpTable);
 export function makeHelpVerb() {
     return {
         name: 'help',
@@ -12,6 +15,7 @@ export function makeHelpVerb() {
                 .map((v) => ({ name: v.name, summary: v.summary }));
             ctx.scrollback.push({
                 kind: 'rich',
+                componentKey: HELP_TABLE_KEY,
                 component: HelpTable,
                 props: {
                     data: {

package/dist/shell-shard/verbs/history.js

@@ -1,12 +1,19 @@
 import HistoryList from '../rich/HistoryList.svelte';
+import { registerRichComponent } from '../rich-registry';
+const HISTORY_LIST_KEY = 'history-list';
+registerRichComponent(HISTORY_LIST_KEY, HistoryList);
 export const historyVerb = {
     name: 'history',
     summary: 'Show the last N history lines. Default 50.',
     async run(ctx, args) {
+        var _a;
         const n = args[0] ? Math.max(1, parseInt(args[0], 10) || 50) : 50;
-        const lines = ctx.session.history.slice(-n);
+        const modeId = ctx.shell.getMode().id;
+        const allLines = (_a = ctx.session.historyByMode[modeId]) !== null && _a !== void 0 ? _a : [];
+        const lines = allLines.slice(-n);
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: HISTORY_LIST_KEY,
             component: HistoryList,
             props: {
                 data: {

package/dist/shell-shard/verbs/index.js

@@ -10,10 +10,7 @@ import { appsVerb, appVerb } from './apps';
 import { shardsVerb } from './shards';
 import { viewsVerb, openVerb, closeVerb, popoutVerb, dockVerb } from './views';
 import { zonesVerb, zoneVerb } from './zones';
-import { pwdVerb, cdVerb, whoamiVerb } from './session';
 import { envVerb } from './env';
-import { lsVerb } from './ls';
-import { catVerb } from './cat';
 import { resetVerb } from './reset';
 export function registerV1Verbs(ctx) {
     ctx.registerVerb(makeHelpVerb());
@@ -30,11 +27,6 @@ export function registerV1Verbs(ctx) {
     ctx.registerVerb(dockVerb);
     ctx.registerVerb(zonesVerb);
     ctx.registerVerb(zoneVerb);
-    ctx.registerVerb(pwdVerb);
-    ctx.registerVerb(cdVerb);
     ctx.registerVerb(envVerb);
-    ctx.registerVerb(whoamiVerb);
-    ctx.registerVerb(lsVerb);
-    ctx.registerVerb(catVerb);
     ctx.registerVerb(resetVerb);
 }

package/dist/shell-shard/verbs/shards.js

@@ -1,4 +1,7 @@
 import ShardsTable from '../rich/ShardsTable.svelte';
+import { registerRichComponent } from '../rich-registry';
+const SHARDS_TABLE_KEY = 'shards-table';
+registerRichComponent(SHARDS_TABLE_KEY, ShardsTable);
 export const shardsVerb = {
     name: 'shards',
     summary: 'List active shards.',
@@ -7,6 +10,7 @@ export const shardsVerb = {
         const shards = ctx.shell.listShards();
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: SHARDS_TABLE_KEY,
             component: ShardsTable,
             props: { data: { shards } },
             ts: Date.now(),

package/dist/shell-shard/verbs/views.js

@@ -1,4 +1,7 @@
 import ViewsTable from '../rich/ViewsTable.svelte';
+import { registerRichComponent } from '../rich-registry';
+const VIEWS_TABLE_KEY = 'views-table';
+registerRichComponent(VIEWS_TABLE_KEY, ViewsTable);
 export const viewsVerb = {
     name: 'views',
     summary: 'List views currently mounted. Pass --standalone to list summonable views instead.',
@@ -28,6 +31,7 @@ export const viewsVerb = {
         const views = ctx.shell.listViewsInCurrentLayout();
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: VIEWS_TABLE_KEY,
             component: ViewsTable,
             props: {
                 data: {

package/dist/shell-shard/verbs/zones.js

@@ -1,5 +1,10 @@
 import ZonesTable from '../rich/ZonesTable.svelte';
 import ZoneTree from '../rich/ZoneTree.svelte';
+import { registerRichComponent } from '../rich-registry';
+const ZONES_TABLE_KEY = 'zones-table';
+const ZONE_TREE_KEY = 'zone-tree';
+registerRichComponent(ZONES_TABLE_KEY, ZonesTable);
+registerRichComponent(ZONE_TREE_KEY, ZoneTree);
 export const zonesVerb = {
     name: 'zones',
     summary: 'List zones for the current user (optionally scoped to a shard).',
@@ -8,6 +13,7 @@ export const zonesVerb = {
         const rows = ctx.shell.listZones(args[0]);
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: ZONES_TABLE_KEY,
             component: ZonesTable,
             props: { data: { rows } },
             ts: Date.now(),
@@ -32,6 +38,7 @@ export const zoneVerb = {
         const value = ctx.shell.readZone(shardId, zoneName);
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: ZONE_TREE_KEY,
             component: ZoneTree,
             props: { data: { value } },
             ts: Date.now(),

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.15.1";
+export declare const VERSION = "0.15.2";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.15.1';
+export const VERSION = '0.15.2';