sh3-core 0.7.5 → 0.8.1

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

@@ -0,0 +1,15 @@
+import type { VerbRegistry, ShellApi } from './registry';
+import type { Scrollback } from './scrollback.svelte';
+import type { SessionClient } from './session-client.svelte';
+import type { TenantFsClient } from './tenant-fs-client';
+import type { ShellMode } from './modes/types';
+export interface DispatchDeps {
+    mode: () => ShellMode;
+    resolver: VerbRegistry;
+    scrollback: Scrollback;
+    session: SessionClient;
+    shell: ShellApi;
+    fs: TenantFsClient;
+    cwd: () => string;
+}
+export declare function makeDispatch(deps: DispatchDeps): (line: string) => Promise<void>;

package/dist/shell-shard/dispatch.js

@@ -0,0 +1,56 @@
+/*
+ * makeDispatch — mode-aware verb dispatch factory for Terminal.svelte.
+ *
+ * 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.
+ */
+export function makeDispatch(deps) {
+    return async function dispatch(line) {
+        var _a;
+        const mode = deps.mode();
+        deps.session.history.push(line);
+        // User-mode $ escape: block server-shell access
+        if (mode.transport === 'none' && line.trimStart().startsWith('$ ')) {
+            deps.scrollback.push({ kind: 'prompt', cwd: deps.cwd(), line, ts: Date.now() });
+            deps.scrollback.push({ kind: 'status', text: 'shell: server shell not available in user mode', level: 'error', ts: Date.now() });
+            return;
+        }
+        const resolution = deps.resolver.resolve(line);
+        if (resolution.kind === 'local') {
+            // Log locally-dispatched verbs for shared history (ws only)
+            if (mode.transport === 'ws') {
+                deps.session.send({ t: 'history-log', line });
+            }
+            deps.scrollback.push({ kind: 'prompt', cwd: deps.cwd(), line, ts: Date.now() });
+            try {
+                await resolution.verb.run({
+                    shell: deps.shell,
+                    scrollback: deps.scrollback,
+                    session: deps.session,
+                    cwd: deps.cwd(),
+                    dispatch,
+                    fs: deps.fs,
+                }, resolution.args);
+            }
+            catch (err) {
+                deps.scrollback.push({
+                    kind: 'status',
+                    text: `shell: verb ${resolution.verb.name} threw — ${err.message}`,
+                    level: 'error',
+                    ts: Date.now(),
+                });
+            }
+            return;
+        }
+        // forward path
+        if (mode.transport === 'ws') {
+            deps.session.send({ t: 'submit', line: resolution.line });
+        }
+        else {
+            const firstToken = (_a = resolution.line.split(/\s+/)[0]) !== null && _a !== void 0 ? _a : '';
+            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() });
+        }
+    };
+}

package/dist/shell-shard/manifest.js

@@ -3,7 +3,7 @@ export const manifest = {
     id: 'shell',
     label: 'Shell',
     version: VERSION,
-    views: [{ id: 'shell:terminal', label: 'Shell' }],
+    views: [{ id: 'shell:terminal', label: 'Shell', standalone: true }],
     // serverBundle intentionally omitted — this shard is a framework built-in
     // and is statically mounted at sh3-server boot. The existing contract in
     // sh3-core/src/shards/types.ts documents that framework-shipped shards do

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

@@ -0,0 +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 function registerBuiltinModes(reg: ShellModeRegistry): void;

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

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

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

@@ -0,0 +1,5 @@
+import type { ShellMode, ShellRole } from './types';
+import type { ShellModeRegistry } from './registry';
+export declare function readLastMode(userId: string): string | null;
+export declare function writeLastMode(userId: string, modeId: string): void;
+export declare function resolveInitialMode(reg: ShellModeRegistry, userId: string, role: ShellRole): ShellMode;

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

@@ -0,0 +1,31 @@
+function key(userId) {
+    return `sh3.shell.lastMode.${userId}`;
+}
+export function readLastMode(userId) {
+    var _a, _b;
+    try {
+        return (_b = (_a = globalThis.localStorage) === null || _a === void 0 ? void 0 : _a.getItem(key(userId))) !== null && _b !== void 0 ? _b : null;
+    }
+    catch (_c) {
+        return null;
+    }
+}
+export function writeLastMode(userId, modeId) {
+    var _a;
+    try {
+        (_a = globalThis.localStorage) === null || _a === void 0 ? void 0 : _a.setItem(key(userId), modeId);
+    }
+    catch (_b) {
+        // Non-browser host or storage disabled — persistence is best-effort.
+    }
+}
+export function resolveInitialMode(reg, userId, role) {
+    const persisted = readLastMode(userId);
+    if (persisted) {
+        const m = reg.get(persisted);
+        if (m && (!m.requiresRole || m.requiresRole === role))
+            return m;
+    }
+    const fallback = role === 'admin' ? 'dev' : 'user';
+    return reg.get(fallback);
+}

package/dist/shell-shard/modes/prefs.test.d.ts

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

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

@@ -0,0 +1,46 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { readLastMode, writeLastMode, resolveInitialMode } from './prefs';
+import { ShellModeRegistry } from './registry';
+import { registerBuiltinModes } from './builtin';
+class MemStorage {
+    constructor() {
+        this.m = new Map();
+    }
+    getItem(k) { var _a; return (_a = this.m.get(k)) !== null && _a !== void 0 ? _a : null; }
+    setItem(k, v) { this.m.set(k, v); }
+    removeItem(k) { this.m.delete(k); }
+}
+beforeEach(() => {
+    globalThis.localStorage = new MemStorage();
+});
+describe('readLastMode / writeLastMode', () => {
+    it('round-trips a mode id for a user', () => {
+        writeLastMode('alice', 'user');
+        expect(readLastMode('alice')).toBe('user');
+    });
+    it('returns null when nothing persisted', () => {
+        expect(readLastMode('bob')).toBeNull();
+    });
+});
+describe('resolveInitialMode', () => {
+    const reg = new ShellModeRegistry();
+    registerBuiltinModes(reg);
+    it('admin with no pref → dev', () => {
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+    });
+    it('user with no pref → user', () => {
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    });
+    it('admin with persisted user → user', () => {
+        writeLastMode('alice', 'user');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('user');
+    });
+    it('user with persisted dev (not allowed) → falls back to user', () => {
+        writeLastMode('alice', 'dev');
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    });
+    it('persisted unknown id → role default', () => {
+        writeLastMode('alice', 'nonsense');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+    });
+});

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

@@ -0,0 +1,7 @@
+import type { ShellMode, ShellRole } from './types';
+export declare class ShellModeRegistry {
+    #private;
+    register(mode: ShellMode): void;
+    get(id: string): ShellMode | undefined;
+    list(role: ShellRole): ShellMode[];
+}

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

@@ -0,0 +1,27 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ShellModeRegistry_modes;
+export class ShellModeRegistry {
+    constructor() {
+        _ShellModeRegistry_modes.set(this, new Map());
+    }
+    register(mode) {
+        __classPrivateFieldGet(this, _ShellModeRegistry_modes, "f").set(mode.id, mode);
+    }
+    get(id) {
+        return __classPrivateFieldGet(this, _ShellModeRegistry_modes, "f").get(id);
+    }
+    list(role) {
+        const out = [];
+        for (const m of __classPrivateFieldGet(this, _ShellModeRegistry_modes, "f").values()) {
+            if (m.requiresRole && m.requiresRole !== role)
+                continue;
+            out.push(m);
+        }
+        return out;
+    }
+}
+_ShellModeRegistry_modes = new WeakMap();

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

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

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

@@ -0,0 +1,35 @@
+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 ssh = { id: 'ssh', label: 'SSH', requiresRole: 'admin', transport: 'custom', autoRelocate: false };
+describe('ShellModeRegistry', () => {
+    let reg;
+    beforeEach(() => {
+        reg = new ShellModeRegistry();
+    });
+    it('registers and retrieves modes', () => {
+        reg.register(dev);
+        expect(reg.get('dev')).toEqual(dev);
+    });
+    it('list(user) excludes admin-only modes', () => {
+        reg.register(dev);
+        reg.register(user);
+        reg.register(ssh);
+        const ids = reg.list('user').map((m) => m.id);
+        expect(ids).toEqual(['user']);
+    });
+    it('list(admin) includes all modes', () => {
+        reg.register(dev);
+        reg.register(user);
+        reg.register(ssh);
+        const ids = reg.list('admin').map((m) => m.id).sort();
+        expect(ids).toEqual(['dev', 'ssh', 'user']);
+    });
+    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+');
+    });
+});

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

@@ -0,0 +1,8 @@
+export type ShellRole = 'admin' | 'user';
+export interface ShellMode {
+    id: string;
+    label: string;
+    requiresRole?: 'admin';
+    transport: 'ws' | 'none' | 'custom';
+    autoRelocate: boolean;
+}

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

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

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

@@ -23,6 +23,12 @@ export type ClientMessage =
 /** Ask the server for its current cwd. */
  | {
     t: 'cwd-query';
+}
+/** Push a cwd change from the frontend (docs tree, file explorer, etc.).
+ *  Server resolves `path` relative to current cwd, validates, broadcasts. */
+ | {
+    t: 'setCwd';
+    path: string;
 };
 export type ServerMessage = 
 /** Sent once on successful attach, immediately after hello. */

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

@@ -19,7 +19,9 @@ import { registerV1Verbs } from './verbs';
 import { listRegisteredApps, getActiveApp } from '../apps/registry.svelte';
 import { launchApp } from '../apps/lifecycle';
 import { registeredShards } from '../shards/activate.svelte';
-import { inspectActiveLayout, focusView, closeTab } from '../layout/inspection';
+import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIntoActiveLayout } from '../layout/inspection';
+import { floatManager } from '../overlays/float';
+import { listStandaloneViews } from '../shards/activate.svelte';
 import { getUser, isAdmin } from '../auth/index';
 /** Walk a layout tree and collect all tab entries (slotId + viewId + label). */
 function collectTabEntries(node) {
@@ -76,16 +78,62 @@ function makeShellApi(_ctx) {
                 return [];
             }
         },
-        // → layout/inspection: focusView(viewId) returns boolean
+        // → layout/inspection: focusView(viewId). Falls back to dockIntoActiveLayout
+        // for standalone views that aren't mounted yet — this is the single
+        // "summon" entry point wired behind the `open` verb.
         openViewInCurrentLayout(viewId) {
             try {
-                const found = focusView(viewId);
-                return found ? { ok: true } : { ok: false, error: `view "${viewId}" not found in current layout` };
+                if (focusView(viewId))
+                    return { ok: true };
+                const standalone = listStandaloneViews().find((v) => v.viewId === viewId);
+                if (standalone) {
+                    const slotId = `standalone:${viewId}:${Date.now()}`;
+                    const ok = dockIntoActiveLayout({ slotId, viewId, label: standalone.label });
+                    return ok ? { ok: true } : { ok: false, error: `could not dock "${viewId}" — no available slot` };
+                }
+                return { ok: false, error: `view "${viewId}" not found in current layout` };
             }
             catch (err) {
                 return { ok: false, error: err instanceof Error ? err.message : String(err) };
             }
         },
+        // → shards/activate.svelte: listStandaloneViews() walks activeShards
+        listStandaloneViews() {
+            return listStandaloneViews();
+        },
+        // → layout/inspection: popoutView(slotId) returns floatId | null
+        popoutSlot(slotId) {
+            try {
+                const floatId = popoutView(slotId);
+                return floatId ? { ok: true, floatId } : { ok: false, error: `slot "${slotId}" not found in docked tree` };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        // → layout/inspection: dockFloat(floatId) returns boolean
+        dockFloat(floatId) {
+            try {
+                const ok = dockFloat(floatId);
+                return ok ? { ok: true } : { ok: false, error: `float "${floatId}" not found or has no dockable content` };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        // → overlays/float: floatManager.list() returns FloatEntry[]
+        listFloats() {
+            return floatManager.list().map((f) => {
+                var _a, _b, _c, _d, _e;
+                const tabs = f.content.type === 'tabs' ? f.content : null;
+                const active = tabs ? (_b = tabs.tabs[(_a = tabs.activeTab) !== null && _a !== void 0 ? _a : 0]) !== null && _b !== void 0 ? _b : tabs.tabs[0] : null;
+                return {
+                    floatId: f.id,
+                    viewId: (_c = active === null || active === void 0 ? void 0 : active.viewId) !== null && _c !== void 0 ? _c : null,
+                    label: (_e = (_d = f.title) !== null && _d !== void 0 ? _d : active === null || active === void 0 ? void 0 : active.label) !== null && _e !== void 0 ? _e : f.id,
+                };
+            });
+        },
         // → layout/inspection: closeTab(slotId) is async (guarded close).
         // Fire-and-forget; the tab disappears asynchronously. ShellApi stays sync.
         closeSlot(slotId) {
@@ -119,12 +167,16 @@ export const shellShard = {
         const shell = makeShellApi(ctx);
         const factory = {
             mount(container, _context) {
+                var _a;
                 const proto = typeof location !== 'undefined' && location.protocol === 'https:' ? 'wss' : 'ws';
                 const host = typeof location !== 'undefined' ? location.host : 'localhost';
                 const wsUrl = `${proto}://${host}/api/shell/session`;
+                const user = getUser();
+                const userId = (_a = user === null || user === void 0 ? void 0 : user.id) !== null && _a !== void 0 ? _a : 'guest';
+                const role = isAdmin() ? 'admin' : 'user';
                 const instance = mount(Terminal, {
                     target: container,
-                    props: { shell, wsUrl },
+                    props: { shell, wsUrl, userId, role },
                 });
                 return {
                     unmount() {

package/dist/shell-shard/tenant-fs-client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Client for /api/fs/*. Read-only today.
+ * Shared across all shell modes so verb implementations stay mode-agnostic.
+ */
+export interface FsEntry {
+    name: string;
+    kind: 'file' | 'dir';
+    size: number;
+    mtime: number;
+}
+export interface FsStat {
+    name: string;
+    kind: 'file' | 'dir';
+    size: number;
+    mtime: number;
+}
+export declare class TenantFsClient {
+    #private;
+    private readonly base;
+    constructor(base?: string);
+    list(path: string): Promise<FsEntry[]>;
+    stat(path: string): Promise<FsStat>;
+    read(path: string): Promise<string>;
+}

package/dist/shell-shard/tenant-fs-client.js

@@ -0,0 +1,44 @@
+/**
+ * Client for /api/fs/*. Read-only today.
+ * Shared across all shell modes so verb implementations stay mode-agnostic.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TenantFsClient_instances, _TenantFsClient_get;
+export class TenantFsClient {
+    constructor(base = '') {
+        _TenantFsClient_instances.add(this);
+        this.base = base;
+    }
+    async list(path) {
+        const res = await __classPrivateFieldGet(this, _TenantFsClient_instances, "m", _TenantFsClient_get).call(this, '/api/fs/list', path);
+        const body = await res.json();
+        return body.entries;
+    }
+    async stat(path) {
+        const res = await __classPrivateFieldGet(this, _TenantFsClient_instances, "m", _TenantFsClient_get).call(this, '/api/fs/stat', path);
+        return await res.json();
+    }
+    async read(path) {
+        const res = await __classPrivateFieldGet(this, _TenantFsClient_instances, "m", _TenantFsClient_get).call(this, '/api/fs/read', path);
+        return await res.text();
+    }
+}
+_TenantFsClient_instances = new WeakSet(), _TenantFsClient_get = async function _TenantFsClient_get(route, path) {
+    const url = `${this.base}${route}?path=${encodeURIComponent(path)}`;
+    const res = await fetch(url, { credentials: 'include' });
+    if (!res.ok) {
+        let msg = `HTTP ${res.status}`;
+        try {
+            const j = await res.json();
+            if (j.error)
+                msg = j.error;
+        }
+        catch ( /* non-json body */_a) { /* non-json body */ }
+        throw new Error(msg);
+    }
+    return res;
+};

package/dist/shell-shard/tenant-fs-client.test.d.ts

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

package/dist/shell-shard/tenant-fs-client.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TenantFsClient } from './tenant-fs-client';
+beforeEach(() => {
+    vi.restoreAllMocks();
+});
+function mockFetchJson(status, body) {
+    globalThis.fetch = vi.fn(async () => new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json' },
+    }));
+}
+describe('TenantFsClient.list', () => {
+    it('GETs /api/fs/list with the encoded path', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (url) => {
+            calls.push(String(url));
+            return new Response(JSON.stringify({ entries: [{ name: 'a', kind: 'file', size: 1, mtime: 0 }] }), { status: 200 });
+        });
+        const c = new TenantFsClient();
+        const entries = await c.list('sub dir');
+        expect(calls[0]).toContain('/api/fs/list?path=sub%20dir');
+        expect(entries).toHaveLength(1);
+    });
+    it('throws on non-2xx', async () => {
+        mockFetchJson(403, { error: 'forbidden' });
+        const c = new TenantFsClient();
+        await expect(c.list('..')).rejects.toThrow(/forbidden/);
+    });
+});
+describe('TenantFsClient.stat', () => {
+    it('returns kind and size', async () => {
+        mockFetchJson(200, { name: 'a.txt', kind: 'file', size: 5, mtime: 0 });
+        const c = new TenantFsClient();
+        const s = await c.stat('a.txt');
+        expect(s).toMatchObject({ kind: 'file', size: 5 });
+    });
+});
+describe('TenantFsClient.read', () => {
+    it('returns body text on 200', async () => {
+        globalThis.fetch = vi.fn(async () => new Response('hello', { status: 200 }));
+        const c = new TenantFsClient();
+        expect(await c.read('a.txt')).toBe('hello');
+    });
+    it('throws structured error on 413', async () => {
+        mockFetchJson(413, { error: 'file too large' });
+        const c = new TenantFsClient();
+        await expect(c.read('big.bin')).rejects.toThrow(/too large/);
+    });
+});

package/dist/shell-shard/terminal-dispatch.test.d.ts

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

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

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi } from 'vitest';
+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 scrollback = { push: (e) => pushed.push(e) };
+    const session = {
+        history: { push: vi.fn() },
+        send: (m) => sent.push(m),
+        cwd: '/',
+    };
+    const fs = {};
+    const shell = {};
+    const resolver = {
+        resolve: (line) => line.startsWith('pwd')
+            ? { kind: 'local', verb: { name: 'pwd', run: async () => { } }, args: [], line }
+            : { kind: 'forward', line },
+    };
+    const dispatch = makeDispatch({
+        mode: () => mode,
+        resolver,
+        scrollback,
+        session,
+        shell,
+        fs,
+        cwd: () => '/',
+    });
+    return { dispatch, sent, pushed };
+}
+describe('dispatch — user mode', () => {
+    it('unknown verbs print error, do not send', async () => {
+        const { dispatch, sent, pushed } = scaffold('user');
+        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');
+        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', () => {
+    it('forwards unknown verbs to server', async () => {
+        const { dispatch, sent } = scaffold('dev');
+        await dispatch('foo');
+        expect(sent.some((m) => m.t === 'submit' && m.line === 'foo')).toBe(true);
+    });
+});

package/dist/shell-shard/toolbar/Toolbar.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+  import type { ToolbarSlotRegistry, ShellSlotCtx } from './slots';
+
+  interface Props {
+    registry: ToolbarSlotRegistry;
+    ctx: ShellSlotCtx;
+    expanded: boolean;
+    onToggle: () => void;
+    slotProps?: Record<string, Record<string, unknown>>;
+  }
+
+  let { registry, ctx, expanded, onToggle, slotProps = {} }: Props = $props();
+
+  let slots = $derived(registry.list(ctx));
+</script>
+
+<div class="toolbar" class:collapsed={!expanded}>
+  <button class="toolbar-toggle" onclick={onToggle} title={expanded ? 'Collapse toolbar' : 'Expand toolbar'}>
+    {expanded ? '▲' : '▼'}
+  </button>
+  {#if expanded}
+    <div class="toolbar-slots">
+      {#each slots as s (s.id)}
+        {@const Slot = s.component}
+        <Slot {...(slotProps[s.id] ?? {})} />
+      {/each}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .toolbar {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 2px 6px;
+    background: var(--shell-toolbar-bg, #1a1a1a);
+    border-bottom: 1px solid var(--shell-border, #333);
+    flex-shrink: 0;
+    min-height: 24px;
+  }
+
+  .toolbar-toggle {
+    background: none;
+    border: none;
+    color: var(--shell-fg-dim, #888);
+    cursor: pointer;
+    font-size: 0.7em;
+    padding: 0 2px;
+    line-height: 1;
+  }
+
+  .toolbar-toggle:hover {
+    color: var(--shell-fg, #ddd);
+  }
+
+  .toolbar-slots {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+  }
+</style>

package/dist/shell-shard/toolbar/Toolbar.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { ToolbarSlotRegistry, ShellSlotCtx } from './slots';
+interface Props {
+    registry: ToolbarSlotRegistry;
+    ctx: ShellSlotCtx;
+    expanded: boolean;
+    onToggle: () => void;
+    slotProps?: Record<string, Record<string, unknown>>;
+}
+declare const Toolbar: import("svelte").Component<Props, {}, "">;
+type Toolbar = ReturnType<typeof Toolbar>;
+export default Toolbar;