sh3-core 0.13.3 → 0.14.0

package/dist/shell-shard/dispatch.js

@@ -4,10 +4,19 @@
  * Pure function (no Svelte reactivity) so it can be unit-tested independently.
  * The mode is passed as a getter so the dispatch closure always sees the
  * current mode without being reconstructed on every mode change.
+ *
+ * Returns a `{ dispatch, cancel }` handle so the caller can abort an
+ * in-flight custom-mode dispatch (e.g. when the user switches mode mid-stream).
  */
+import { makeShellModeOutput } from './output';
 export function makeDispatch(deps) {
-    return async function dispatch(line) {
-        var _a;
+    let activeController = null;
+    async function dispatch(line) {
+        var _a, _b, _c, _d;
+        // Abort any in-flight custom dispatch when a new line is submitted.
+        activeController === null || activeController === void 0 ? void 0 : activeController.abort();
+        const controller = new AbortController();
+        activeController = controller;
         const mode = deps.mode();
         deps.session.history.push(line);
         // User-mode $ escape: block server-shell access
@@ -46,11 +55,55 @@ export function makeDispatch(deps) {
         // forward path
         if (mode.transport === 'ws') {
             deps.session.send({ t: 'submit', line: resolution.line });
+            return;
         }
-        else {
-            const firstToken = (_a = resolution.line.split(/\s+/)[0]) !== null && _a !== void 0 ? _a : '';
+        if (mode.transport === 'custom') {
             deps.scrollback.push({ kind: 'prompt', cwd: deps.cwd(), line: resolution.line, ts: Date.now() });
-            deps.scrollback.push({ kind: 'status', text: `unknown verb: ${firstToken}`, level: 'error', ts: Date.now() });
+            const desc = (_b = (_a = deps.customMode) === null || _a === void 0 ? void 0 : _a.call(deps, mode.id)) !== null && _b !== void 0 ? _b : null;
+            if (!desc) {
+                deps.scrollback.push({
+                    kind: 'status',
+                    text: `mode '${mode.id}' is no longer available`,
+                    level: 'error',
+                    ts: Date.now(),
+                });
+                return;
+            }
+            if (desc.runsOn === 'server') {
+                deps.scrollback.push({
+                    kind: 'status',
+                    text: 'server-side modes are not yet supported (planned for a future release)',
+                    level: 'error',
+                    ts: Date.now(),
+                });
+                return;
+            }
+            const output = makeShellModeOutput(deps.scrollback);
+            try {
+                await desc.dispatch({ line: resolution.line, cwd: deps.cwd(), signal: controller.signal }, output);
+            }
+            catch (err) {
+                if ((err === null || err === void 0 ? void 0 : err.name) === 'AbortError') {
+                    deps.scrollback.push({ kind: 'status', text: 'mode dispatch aborted', level: 'info', ts: Date.now() });
+                }
+                else {
+                    deps.scrollback.push({
+                        kind: 'status',
+                        text: `mode '${mode.id}' threw — ${(_c = err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : String(err)}`,
+                        level: 'error',
+                        ts: Date.now(),
+                    });
+                }
+            }
+            return;
         }
+        // 'none' transport, unknown verb: print error
+        const firstToken = (_d = resolution.line.split(/\s+/)[0]) !== null && _d !== void 0 ? _d : '';
+        deps.scrollback.push({ kind: 'prompt', cwd: deps.cwd(), line: resolution.line, ts: Date.now() });
+        deps.scrollback.push({ kind: 'status', text: `unknown verb: ${firstToken}`, level: 'error', ts: Date.now() });
+    }
+    return {
+        dispatch,
+        cancel: () => activeController === null || activeController === void 0 ? void 0 : activeController.abort(),
     };
 }

package/dist/shell-shard/modes/builtin.d.ts

@@ -1,5 +1,5 @@
 import { ShellModeRegistry } from './registry';
 import type { ShellMode } from './types';
-export declare const DEV_MODE: ShellMode;
-export declare const USER_MODE: ShellMode;
+export declare const BASH_MODE: ShellMode;
+export declare const SH3_MODE: ShellMode;
 export declare function registerBuiltinModes(reg: ShellModeRegistry): void;

package/dist/shell-shard/modes/builtin.js

@@ -1,18 +1,18 @@
 import { ShellModeRegistry } from './registry';
-export const DEV_MODE = {
-    id: 'dev',
-    label: 'Dev',
+export const BASH_MODE = {
+    id: 'bash',
+    label: 'Bash',
     requiresRole: 'admin',
     transport: 'ws',
     autoRelocate: false,
 };
-export const USER_MODE = {
-    id: 'user',
-    label: 'User',
+export const SH3_MODE = {
+    id: 'sh3',
+    label: 'SH3',
     transport: 'none',
     autoRelocate: true,
 };
 export function registerBuiltinModes(reg) {
-    reg.register(DEV_MODE);
-    reg.register(USER_MODE);
+    reg.register(BASH_MODE);
+    reg.register(SH3_MODE);
 }

package/dist/shell-shard/modes/prefs.js

@@ -26,6 +26,6 @@ export function resolveInitialMode(reg, userId, role) {
         if (m && (!m.requiresRole || m.requiresRole === role))
             return m;
     }
-    const fallback = role === 'admin' ? 'dev' : 'user';
+    const fallback = role === 'admin' ? 'bash' : 'sh3';
     return reg.get(fallback);
 }

package/dist/shell-shard/modes/prefs.test.js

@@ -15,8 +15,8 @@ beforeEach(() => {
 });
 describe('readLastMode / writeLastMode', () => {
     it('round-trips a mode id for a user', () => {
-        writeLastMode('alice', 'user');
-        expect(readLastMode('alice')).toBe('user');
+        writeLastMode('alice', 'sh3');
+        expect(readLastMode('alice')).toBe('sh3');
     });
     it('returns null when nothing persisted', () => {
         expect(readLastMode('bob')).toBeNull();
@@ -25,22 +25,22 @@ describe('readLastMode / writeLastMode', () => {
 describe('resolveInitialMode', () => {
     const reg = new ShellModeRegistry();
     registerBuiltinModes(reg);
-    it('admin with no pref → dev', () => {
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+    it('admin with no pref → bash', () => {
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('bash');
     });
-    it('user with no pref → user', () => {
-        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    it('user with no pref → sh3', () => {
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('sh3');
     });
-    it('admin with persisted user → user', () => {
-        writeLastMode('alice', 'user');
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('user');
+    it('admin with persisted sh3 → sh3', () => {
+        writeLastMode('alice', 'sh3');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('sh3');
     });
-    it('user with persisted dev (not allowed) → falls back to user', () => {
-        writeLastMode('alice', 'dev');
-        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    it('user with persisted bash (not allowed) → falls back to sh3', () => {
+        writeLastMode('alice', 'bash');
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('sh3');
     });
     it('persisted unknown id → role default', () => {
         writeLastMode('alice', 'nonsense');
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('bash');
     });
 });

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

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { ShellModeRegistry } from './registry';
-const dev = { id: 'dev', label: 'Dev', requiresRole: 'admin', transport: 'ws', autoRelocate: false };
-const user = { id: 'user', label: 'User', transport: 'none', autoRelocate: true };
+const bash = { id: 'bash', label: 'Bash', requiresRole: 'admin', transport: 'ws', autoRelocate: false };
+const sh3 = { id: 'sh3', label: 'SH3', transport: 'none', autoRelocate: true };
 const ssh = { id: 'ssh', label: 'SSH', requiresRole: 'admin', transport: 'custom', autoRelocate: false };
 describe('ShellModeRegistry', () => {
     let reg;
@@ -9,27 +9,27 @@ describe('ShellModeRegistry', () => {
         reg = new ShellModeRegistry();
     });
     it('registers and retrieves modes', () => {
-        reg.register(dev);
-        expect(reg.get('dev')).toEqual(dev);
+        reg.register(bash);
+        expect(reg.get('bash')).toEqual(bash);
     });
     it('list(user) excludes admin-only modes', () => {
-        reg.register(dev);
-        reg.register(user);
+        reg.register(bash);
+        reg.register(sh3);
         reg.register(ssh);
         const ids = reg.list('user').map((m) => m.id);
-        expect(ids).toEqual(['user']);
+        expect(ids).toEqual(['sh3']);
     });
     it('list(admin) includes all modes', () => {
-        reg.register(dev);
-        reg.register(user);
+        reg.register(bash);
+        reg.register(sh3);
         reg.register(ssh);
         const ids = reg.list('admin').map((m) => m.id).sort();
-        expect(ids).toEqual(['dev', 'ssh', 'user']);
+        expect(ids).toEqual(['bash', 'sh3', 'ssh']);
     });
     it('re-registering same id replaces the mode', () => {
         var _a;
-        reg.register(dev);
-        reg.register(Object.assign(Object.assign({}, dev), { label: 'Dev+' }));
-        expect((_a = reg.get('dev')) === null || _a === void 0 ? void 0 : _a.label).toBe('Dev+');
+        reg.register(bash);
+        reg.register(Object.assign(Object.assign({}, bash), { label: 'Bash+' }));
+        expect((_a = reg.get('bash')) === null || _a === void 0 ? void 0 : _a.label).toBe('Bash+');
     });
 });

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

@@ -0,0 +1,3 @@
+import type { Scrollback } from './scrollback.svelte';
+import type { ShellModeOutput } from './contract';
+export declare function makeShellModeOutput(sb: Scrollback): ShellModeOutput;

package/dist/shell-shard/output.js

@@ -0,0 +1,75 @@
+/*
+ * makeShellModeOutput — wraps a Scrollback in the typed ShellModeOutput
+ * surface external mode shards consume. The framework is the only writer to
+ * scrollback shapes; mode authors talk to this handle.
+ *
+ * Streaming entries carry a `__streamState` prop set to 'streaming' on push,
+ * 'complete' on complete(), 'error' on error(). The entry's component is
+ * expected to read this prop (or ignore it — it's optional).
+ */
+function findRich(sb, entryId) {
+    return sb.entries.find((e) => e.kind === 'rich' && e.id === entryId);
+}
+function makeRichHandle(sb, entryId) {
+    return {
+        update(patch) {
+            const entry = findRich(sb, entryId);
+            if (!entry)
+                return;
+            Object.assign(entry.props, patch);
+        },
+    };
+}
+function lastRichId(sb) {
+    const last = sb.entries[sb.entries.length - 1];
+    return last.id;
+}
+export function makeShellModeOutput(sb) {
+    return {
+        text(stream, chunk) {
+            sb.push({ kind: 'text', stream, chunks: [chunk], ts: Date.now() });
+        },
+        status(level, msg) {
+            sb.push({ kind: 'status', text: msg, level, ts: Date.now() });
+        },
+        rich(component, props) {
+            sb.push({ kind: 'rich', component, props: Object.assign({}, props), ts: Date.now() });
+            return makeRichHandle(sb, lastRichId(sb));
+        },
+        stream(component, initialProps) {
+            sb.push({
+                kind: 'rich',
+                component,
+                props: Object.assign(Object.assign({}, initialProps), { __streamState: 'streaming' }),
+                ts: Date.now(),
+            });
+            const id = lastRichId(sb);
+            return {
+                append(patch) {
+                    const entry = findRich(sb, id);
+                    if (!entry)
+                        return;
+                    Object.assign(entry.props, patch);
+                },
+                complete() {
+                    const entry = findRich(sb, id);
+                    if (!entry)
+                        return;
+                    entry.props.__streamState = 'complete';
+                },
+                error(err) {
+                    var _a;
+                    const entry = findRich(sb, id);
+                    if (entry)
+                        entry.props.__streamState = 'error';
+                    sb.push({
+                        kind: 'status',
+                        text: `mode: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err)}`,
+                        level: 'error',
+                        ts: Date.now(),
+                    });
+                },
+            };
+        },
+    };
+}

package/dist/shell-shard/output.test.d.ts

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

package/dist/shell-shard/output.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { Scrollback } from './scrollback.svelte';
+import { makeShellModeOutput } from './output';
+const FakeComponent = (() => { });
+describe('makeShellModeOutput', () => {
+    it('text() pushes coalescing text entries', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        out.text('stdout', 'hello ');
+        out.text('stdout', 'world');
+        const text = sb.entries.filter((e) => e.kind === 'text');
+        expect(text).toHaveLength(1);
+        expect(text[0].chunks.join('')).toBe('hello world');
+    });
+    it('status() pushes a status entry with the right level', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        out.status('warn', 'careful');
+        const s = sb.entries.find((e) => e.kind === 'status');
+        expect(s).toBeDefined();
+        expect(s.level).toBe('warn');
+        expect(s.text).toBe('careful');
+    });
+    it('rich().update() mutates the live entry props', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        const handle = out.rich(FakeComponent, { tokens: 'a' });
+        handle.update({ tokens: 'ab' });
+        const entry = sb.entries.find((e) => e.kind === 'rich');
+        expect(entry.props.tokens).toBe('ab');
+    });
+    it('stream() marks the entry mid-stream until complete()', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        const h = out.stream(FakeComponent, { tokens: '' });
+        let entry = sb.entries.find((e) => e.kind === 'rich');
+        expect(entry.props.__streamState).toBe('streaming');
+        h.append({ tokens: 'a' });
+        expect(entry.props.tokens).toBe('a');
+        h.complete();
+        expect(entry.props.__streamState).toBe('complete');
+    });
+    it('stream().error() marks the entry errored and pushes a status', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        const h = out.stream(FakeComponent, { tokens: '' });
+        h.error(new Error('boom'));
+        const entry = sb.entries.find((e) => e.kind === 'rich');
+        expect(entry.props.__streamState).toBe('error');
+        const s = sb.entries.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(s).toBeDefined();
+        expect(s.text).toMatch(/boom/);
+    });
+});

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

@@ -0,0 +1,13 @@
+import type { ShardContext } from '../shards/types';
+import { type ShellModeDescriptor } from './contract';
+/**
+ * Register a shell-mode descriptor from a shard's `activate(ctx)`. The mode
+ * appears in the picker and in `mode` verb output; submitted lines that don't
+ * match a local verb route to `descriptor.dispatch(input, output)`.
+ *
+ * Thin wrapper around `ctx.contributions.register` so authors get
+ * type-checking without `ShardContext` growing another method. Returns the
+ * upstream disposer; calling it is optional — the framework auto-unregisters
+ * when the owning shard deactivates.
+ */
+export declare function registerShellMode(ctx: ShardContext, descriptor: ShellModeDescriptor): () => void;

package/dist/shell-shard/registerShellMode.js

@@ -0,0 +1,14 @@
+import { SHELL_MODE_CONTRIBUTION_POINT } from './contract';
+/**
+ * Register a shell-mode descriptor from a shard's `activate(ctx)`. The mode
+ * appears in the picker and in `mode` verb output; submitted lines that don't
+ * match a local verb route to `descriptor.dispatch(input, output)`.
+ *
+ * Thin wrapper around `ctx.contributions.register` so authors get
+ * type-checking without `ShardContext` growing another method. Returns the
+ * upstream disposer; calling it is optional — the framework auto-unregisters
+ * when the owning shard deactivates.
+ */
+export function registerShellMode(ctx, descriptor) {
+    return ctx.contributions.register(SHELL_MODE_CONTRIBUTION_POINT, descriptor);
+}

package/dist/shell-shard/registerShellMode.test.d.ts

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

package/dist/shell-shard/registerShellMode.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi } from 'vitest';
+import { registerShellMode } from './registerShellMode';
+import { SHELL_MODE_CONTRIBUTION_POINT } from './contract';
+describe('registerShellMode', () => {
+    it('registers under the canonical contribution point id', () => {
+        const dispose = vi.fn();
+        const register = vi.fn(() => dispose);
+        const ctx = { contributions: { register } };
+        const desc = {
+            id: 'gemini',
+            label: 'Gemini',
+            runsOn: 'client',
+            dispatch: async () => { },
+        };
+        const ret = registerShellMode(ctx, desc);
+        expect(register).toHaveBeenCalledWith(SHELL_MODE_CONTRIBUTION_POINT, desc);
+        expect(ret).toBe(dispose);
+    });
+});

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

@@ -163,6 +163,13 @@ function makeShellApi(_ctx) {
                 admin: isAdmin(),
             };
         },
+        // Mode switching is per-view state owned by Terminal.svelte; the base
+        // ShellApi cannot reach it from the shard scope. Terminal.svelte wraps
+        // this object and overrides setMode/listModes with the live registry +
+        // setMode closure. Verbs called outside a terminal context fall through
+        // these stubs (no-op switch, empty list).
+        setMode(_id) { return false; },
+        listModes() { return []; },
     };
 }
 /**
@@ -205,7 +212,7 @@ export const shellShard = {
                 const role = isAdmin() ? 'admin' : 'user';
                 const instance = mount(Terminal, {
                     target: container,
-                    props: { shell, wsUrl, userId, role },
+                    props: { shell, wsUrl, userId, role, contributions: ctx.contributions },
                 });
                 return {
                     unmount() {

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

@@ -3,9 +3,9 @@ import { makeDispatch } from './dispatch';
 function scaffold(modeId) {
     const sent = [];
     const pushed = [];
-    const mode = modeId === 'dev'
-        ? { id: 'dev', label: 'Dev', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }
-        : { id: 'user', label: 'User', transport: 'none', autoRelocate: true };
+    const mode = modeId === 'bash'
+        ? { 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 session = {
         history: { push: vi.fn() },
@@ -19,7 +19,7 @@ function scaffold(modeId) {
             ? { kind: 'local', verb: { name: 'pwd', run: async () => { } }, args: [], line }
             : { kind: 'forward', line },
     };
-    const dispatch = makeDispatch({
+    const { dispatch } = makeDispatch({
         mode: () => mode,
         resolver,
         scrollback,
@@ -30,23 +30,23 @@ function scaffold(modeId) {
     });
     return { dispatch, sent, pushed };
 }
-describe('dispatch — user mode', () => {
+describe('dispatch — sh3 mode', () => {
     it('unknown verbs print error, do not send', async () => {
-        const { dispatch, sent, pushed } = scaffold('user');
+        const { dispatch, sent, pushed } = scaffold('sh3');
         await dispatch('foo');
         expect(sent).toEqual([]);
         expect(pushed.some((e) => e.kind === 'status' && /unknown verb/.test(e.text))).toBe(true);
     });
     it('$ escape prints error', async () => {
-        const { dispatch, sent, pushed } = scaffold('user');
+        const { dispatch, sent, pushed } = scaffold('sh3');
         await dispatch('$ ls');
         expect(sent).toEqual([]);
         expect(pushed.some((e) => e.kind === 'status' && /server shell not available/.test(e.text))).toBe(true);
     });
 });
-describe('dispatch — dev mode', () => {
+describe('dispatch — bash mode', () => {
     it('forwards unknown verbs to server', async () => {
-        const { dispatch, sent } = scaffold('dev');
+        const { dispatch, sent } = scaffold('bash');
         await dispatch('foo');
         expect(sent.some((m) => m.t === 'submit' && m.line === 'foo')).toBe(true);
     });

package/dist/shell-shard/toolbar/slots/ModeSlot.svelte

@@ -1,67 +1,27 @@
 <script lang="ts">
-  import type { ShellMode, ShellRole } from '../../modes/types';
-  import type { ShellModeRegistry } from '../../modes/registry';
+  import type { ShellMode } from '../../modes/types';
+  import Segmented from '../../../primitives/widgets/Segmented.svelte';
+  import type { SegmentedOption } from '../../../primitives/widgets/Segmented';
 
   interface Props {
     mode: ShellMode;
-    role: ShellRole;
-    registry: ShellModeRegistry;
+    modes: ShellMode[];
     onSelect: (id: string) => void;
   }
+  let { mode, modes, onSelect }: Props = $props();
 
-  let { mode, role, registry, onSelect }: Props = $props();
-
-  let modes = $derived(registry.list(role));
+  let options: SegmentedOption[] = $derived(
+    modes.map((m) => ({ value: m.id, label: m.label })),
+  );
 </script>
 
-{#if role === 'admin'}
-  <div class="mode-bar" role="toolbar" aria-label="Shell mode">
-    {#each modes as m (m.id)}
-      <button
-        type="button"
-        class="mode-btn"
-        class:active={m.id === mode.id}
-        aria-pressed={m.id === mode.id}
-        onclick={() => onSelect(m.id)}
-      >
-        {m.label}
-      </button>
-    {/each}
-  </div>
-{:else}
+{#if modes.length >= 2}
+  <Segmented {options} value={mode.id} size="sm" onchange={(next) => onSelect(next)} />
+{:else if modes.length === 1}
   <span class="mode-label">{mode.label}</span>
 {/if}
 
 <style>
-  .mode-bar {
-    display: inline-flex;
-    gap: 2px;
-    padding: 1px;
-    border: 1px solid var(--shell-border, #444);
-    border-radius: 3px;
-  }
-
-  .mode-btn {
-    background: none;
-    border: none;
-    color: var(--shell-fg-dim, var(--shell-fg-muted, #888));
-    padding: 2px 8px;
-    border-radius: 2px;
-    cursor: pointer;
-    font-size: 0.85em;
-    line-height: 1.4;
-  }
-
-  .mode-btn:hover {
-    background: var(--shell-hover, color-mix(in srgb, var(--shell-fg, #ddd) 10%, transparent));
-    color: var(--shell-fg, #ddd);
-  }
-
-  .mode-btn.active {
-    background: var(--shell-accent, #7c7cf0);
-    color: var(--shell-bg, #1a1a2e);
-  }
-
   .mode-label {
     font-size: 0.85em;
     color: var(--shell-fg-dim, var(--shell-fg-muted, #888));

package/dist/shell-shard/toolbar/slots/ModeSlot.svelte.d.ts

@@ -1,9 +1,7 @@
-import type { ShellMode, ShellRole } from '../../modes/types';
-import type { ShellModeRegistry } from '../../modes/registry';
+import type { ShellMode } from '../../modes/types';
 interface Props {
     mode: ShellMode;
-    role: ShellRole;
-    registry: ShellModeRegistry;
+    modes: ShellMode[];
     onSelect: (id: string) => void;
 }
 declare const ModeSlot: import("svelte").Component<Props, {}, "">;

package/dist/shell-shard/toolbar/slots.test.js

@@ -2,27 +2,27 @@ import { describe, it, expect } from 'vitest';
 import { ToolbarSlotRegistry } from './slots';
 const A = { id: 'a', order: 20, visible: () => true, component: {} };
 const B = { id: 'b', order: 10, visible: () => true, component: {} };
-const C = { id: 'c', order: 30, visible: (ctx) => ctx.mode.id === 'user', component: {} };
-const userCtx = { mode: { id: 'user', label: 'User', transport: 'none', autoRelocate: true }, role: 'user' };
-const devCtx = { mode: { id: 'dev', label: 'Dev', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }, role: 'admin' };
+const C = { id: 'c', order: 30, visible: (ctx) => ctx.mode.id === 'sh3', component: {} };
+const sh3Ctx = { mode: { id: 'sh3', label: 'SH3', transport: 'none', autoRelocate: true }, role: 'user' };
+const bashCtx = { mode: { id: 'bash', label: 'Bash', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }, role: 'admin' };
 describe('ToolbarSlotRegistry', () => {
     it('lists visible slots in order', () => {
         const r = new ToolbarSlotRegistry();
         r.register(A);
         r.register(B);
         r.register(C);
-        expect(r.list(userCtx).map((s) => s.id)).toEqual(['b', 'a', 'c']);
+        expect(r.list(sh3Ctx).map((s) => s.id)).toEqual(['b', 'a', 'c']);
     });
     it('filters by visible', () => {
         const r = new ToolbarSlotRegistry();
         r.register(A);
         r.register(C);
-        expect(r.list(devCtx).map((s) => s.id)).toEqual(['a']);
+        expect(r.list(bashCtx).map((s) => s.id)).toEqual(['a']);
     });
     it('re-registering by id replaces', () => {
         const r = new ToolbarSlotRegistry();
         r.register(A);
         r.register(Object.assign(Object.assign({}, A), { order: 99 }));
-        expect(r.list(userCtx)[0].order).toBe(99);
+        expect(r.list(sh3Ctx)[0].order).toBe(99);
     });
 });

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

@@ -4,6 +4,7 @@
  */
 import { makeHelpVerb } from './help';
 import { clearVerb } from './clear';
+import { modeVerb } from './mode';
 import { historyVerb } from './history';
 import { appsVerb, appVerb } from './apps';
 import { shardsVerb } from './shards';
@@ -17,6 +18,7 @@ import { resetVerb } from './reset';
 export function registerV1Verbs(ctx) {
     ctx.registerVerb(makeHelpVerb());
     ctx.registerVerb(clearVerb);
+    ctx.registerVerb(modeVerb);
     ctx.registerVerb(historyVerb);
     ctx.registerVerb(appsVerb);
     ctx.registerVerb(appVerb);

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

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