sh3-core 0.15.0 → 0.15.2

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();
@@ -135,6 +163,7 @@ export function makeShellApiHeadless() {
         },
         setMode(_id) { return false; },
         listModes() { return []; },
+        getMode() { return { id: 'sh3', label: 'sh3' }; },
     };
 }
 export function makeShellApiForTest() {

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,12 +1,19 @@
 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.',
+    programmatic: true,
     async run(ctx) {
         const apps = ctx.shell.listApps();
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: APPS_TABLE_KEY,
             component: AppsTable,
             props: {
                 data: {
@@ -29,6 +36,7 @@ export const appsVerb = {
 export const appVerb = {
     name: 'app',
     summary: 'Show the currently active app.',
+    programmatic: true,
     async run(ctx) {
         const active = ctx.shell.getActiveApp();
         if (!active) {
@@ -42,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,13 +1,21 @@
 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',
         summary: 'List verbs or show detail for one.',
+        globalVerb: true,
         async run(ctx) {
-            const rows = listVerbs().map((v) => ({ name: v.name, summary: v.summary }));
+            const inSh3 = ctx.shell.getMode().id === 'sh3';
+            const rows = listVerbs()
+                .filter((v) => inSh3 || v.globalVerb === true)
+                .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/help.svelte.test.d.ts

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

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

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { makeHelpVerb } from './help';
+import { registerVerb, __resetViewRegistryForTest } from '../../shards/registry';
+function makeCtx(modeId) {
+    const pushed = [];
+    const ctx = {
+        shell: { getMode: () => ({ id: modeId, label: modeId }) },
+        scrollback: { push: (e) => pushed.push(e) },
+        session: {},
+        cwd: '/',
+        dispatch: async () => { },
+        fs: {},
+    };
+    return { ctx, pushed };
+}
+const sh3Verb = { name: 'apps', summary: 'list apps', async run() { } };
+const globalA = { name: 'clear', summary: 'clear scrollback', globalVerb: true, async run() { } };
+const globalB = { name: 'mode', summary: 'switch mode', globalVerb: true, async run() { } };
+describe('help verb', () => {
+    beforeEach(() => {
+        __resetViewRegistryForTest();
+        registerVerb('apps', sh3Verb, 'shell');
+        registerVerb('clear', globalA, 'shell');
+        registerVerb('mode', globalB, 'shell');
+        registerVerb('help', makeHelpVerb(), 'shell');
+    });
+    it('lists every registered verb in sh3 mode', async () => {
+        const help = makeHelpVerb();
+        const { ctx, pushed } = makeCtx('sh3');
+        await help.run(ctx, []);
+        const rich = pushed.find((e) => e.kind === 'rich');
+        const names = rich.props.data.rows.map((r) => r.name);
+        expect(names).toContain('apps');
+        expect(names).toContain('clear');
+        expect(names).toContain('mode');
+        expect(names).toContain('help');
+    });
+    it('lists only globalVerb-flagged verbs in a custom mode', async () => {
+        const help = makeHelpVerb();
+        const { ctx, pushed } = makeCtx('gemini');
+        await help.run(ctx, []);
+        const rich = pushed.find((e) => e.kind === 'rich');
+        const names = rich.props.data.rows.map((r) => r.name);
+        expect(names).toContain('clear');
+        expect(names).toContain('mode');
+        expect(names).toContain('help');
+        expect(names).not.toContain('apps');
+    });
+    it('is flagged globalVerb so it resolves in custom modes', () => {
+        const help = makeHelpVerb();
+        expect(help.globalVerb).toBe(true);
+    });
+});

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,11 +1,16 @@
 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.',
+    programmatic: true,
     async run(ctx) {
         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,7 +1,11 @@
 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.',
+    programmatic: true,
     async run(ctx, args) {
         if (args.includes('--standalone')) {
             const standalones = ctx.shell.listStandaloneViews();
@@ -27,6 +31,7 @@ export const viewsVerb = {
         const views = ctx.shell.listViewsInCurrentLayout();
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: VIEWS_TABLE_KEY,
             component: ViewsTable,
             props: {
                 data: {
@@ -52,6 +57,7 @@ export const viewsVerb = {
 export const openVerb = {
     name: 'open',
     summary: 'Open a view from any active shard into the current layout.',
+    programmatic: true,
     async run(ctx, args) {
         var _a;
         const viewId = args[0];
@@ -86,6 +92,7 @@ export const openVerb = {
 export const popoutVerb = {
     name: 'popout',
     summary: 'Pop a docked view out into a float by slot id.',
+    programmatic: true,
     async run(ctx, args) {
         var _a;
         const slotId = args[0];
@@ -120,6 +127,7 @@ export const popoutVerb = {
 export const dockVerb = {
     name: 'dock',
     summary: 'Dock a float back into the current layout by float id. Run with no args to list floats.',
+    programmatic: true,
     async run(ctx, args) {
         var _a;
         const floatId = args[0];
@@ -166,6 +174,7 @@ export const dockVerb = {
 export const closeVerb = {
     name: 'close',
     summary: 'Close a view by slot id.',
+    programmatic: true,
     async run(ctx, args) {
         var _a;
         const slotId = args[0];

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

@@ -1,12 +1,19 @@
 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).',
+    programmatic: true,
     async run(ctx, args) {
         const rows = ctx.shell.listZones(args[0]);
         ctx.scrollback.push({
             kind: 'rich',
+            componentKey: ZONES_TABLE_KEY,
             component: ZonesTable,
             props: { data: { rows } },
             ts: Date.now(),
@@ -16,6 +23,7 @@ export const zonesVerb = {
 export const zoneVerb = {
     name: 'zone',
     summary: 'Dump the contents of a zone as a collapsible JSON tree.',
+    programmatic: true,
     async run(ctx, args) {
         const [shardId, zoneName] = args;
         if (!shardId || !zoneName) {
@@ -30,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/verbs/types.d.ts

@@ -77,6 +77,15 @@ export interface ShellApi {
         id: string;
         label: string;
     }[];
+    /**
+     * Active shell mode. Returns `{ id: 'sh3', label: 'sh3' }` from headless
+     * contexts (no terminal view mounted) so callers can rely on a stable
+     * shape — Terminal.svelte overrides this with the live mode.
+     */
+    getMode(): {
+        id: string;
+        label: string;
+    };
 }
 export interface VerbContext {
     shell: ShellApi;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.15.0";
+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.0';
+export const VERSION = '0.15.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "type": "module",
   "files": [
     "dist"

package/dist/app-appearance/AppAppearanceModal.svelte.d.ts

@@ -1,8 +0,0 @@
-interface Props {
-    appId: string;
-    appLabel: string;
-    close: () => void;
-}
-declare const AppAppearanceModal: import("svelte").Component<Props, {}, "">;
-type AppAppearanceModal = ReturnType<typeof AppAppearanceModal>;
-export default AppAppearanceModal;

package/dist/shell-shard/verbs/cat.d.ts

@@ -1,2 +0,0 @@
-import type { Verb } from '../../verbs/types';
-export declare const catVerb: Verb;