sh3-core 0.7.3 → 0.8.0

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

@@ -1,7 +1,10 @@
 import { type ShellApi } from './registry';
+import type { ShellRole } from './modes/types';
 interface Props {
     shell: ShellApi;
     wsUrl: string;
+    userId: string;
+    role: ShellRole;
 }
 declare const Terminal: import("svelte").Component<Props, {}, "">;
 type Terminal = ReturnType<typeof Terminal>;

package/dist/shell-shard/auto-relocate.d.ts

@@ -0,0 +1,12 @@
+import type { TenantFsClient } from './tenant-fs-client';
+export interface RelocateInput {
+    modeAutoRelocate: boolean;
+    focusLocked: boolean;
+    focusedShardId: string | null;
+    currentShardId: string;
+}
+export interface RelocateEffect {
+    kind: 'noop' | 'relocate';
+    path?: string;
+}
+export declare function computeRelocate(input: RelocateInput, fs: TenantFsClient): Promise<RelocateEffect>;

package/dist/shell-shard/auto-relocate.js

@@ -0,0 +1,20 @@
+export async function computeRelocate(input, fs) {
+    if (!input.modeAutoRelocate)
+        return { kind: 'noop' };
+    if (input.focusLocked)
+        return { kind: 'noop' };
+    if (input.focusedShardId === null)
+        return { kind: 'noop' };
+    if (input.focusedShardId === input.currentShardId)
+        return { kind: 'noop' };
+    const path = input.focusedShardId;
+    try {
+        const s = await fs.stat(path);
+        if (s.kind !== 'dir')
+            return { kind: 'noop' };
+    }
+    catch (_a) {
+        return { kind: 'noop' };
+    }
+    return { kind: 'relocate', path };
+}

package/dist/shell-shard/auto-relocate.test.d.ts

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

package/dist/shell-shard/auto-relocate.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from 'vitest';
+import { computeRelocate } from './auto-relocate';
+const statOk = { list: vi.fn(), read: vi.fn(), stat: async () => ({ name: 'notes', kind: 'dir', size: 0, mtime: 0 }) };
+const statMissing = { list: vi.fn(), read: vi.fn(), stat: async () => { throw new Error('not found'); } };
+const statFile = { list: vi.fn(), read: vi.fn(), stat: async () => ({ name: 'notes', kind: 'file', size: 0, mtime: 0 }) };
+describe('computeRelocate', () => {
+    it('noop when mode disables auto-relocate', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: false, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when focus-lock is on', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: true, focusedShardId: 'notes', currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when nothing relevant is focused', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: null, currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when focusing the shell itself', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'shell', currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when target documents folder does not exist', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statMissing);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when target is a file, not a directory', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statFile);
+        expect(r.kind).toBe('noop');
+    });
+    it('relocates to the shard id path on happy path', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statOk);
+        expect(r).toEqual({ kind: 'relocate', path: 'notes' });
+    });
+});

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/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

@@ -119,12 +119,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;