sh3-core 0.15.2 → 0.15.4

package/dist/overlays/FloatFrame.svelte

@@ -33,6 +33,11 @@
   import type { FloatEntry } from '../layout/types';
   import { shell } from '../shellRuntime.svelte';
   import { makeSelectionApi } from '../actions/selection.svelte';
+  import { spawnSatellite } from '../shellApi/window';
+  import { walkShardsForContent } from '../satellite/walkShards';
+
+  const isTauri =
+    typeof (globalThis as Record<string, unknown>).__TAURI_INTERNALS__ !== 'undefined';
 
   const floatHeaderSelection = makeSelectionApi('__layouts__');
 
@@ -98,6 +103,7 @@
     if (e.button !== 0) return;
     if ((e.target as HTMLElement).closest('.sh3-float-close')) return;
     if ((e.target as HTMLElement).closest('.sh3-float-maximize')) return;
+    if ((e.target as HTMLElement).closest('.sh3-float-popout')) return;
     const target = e.currentTarget as HTMLElement;
     target.setPointerCapture?.(e.pointerId);
     dragging = true;
@@ -128,6 +134,7 @@
   function onHeaderDblClick(e: MouseEvent): void {
     if ((e.target as HTMLElement).closest('.sh3-float-close')) return;
     if ((e.target as HTMLElement).closest('.sh3-float-maximize')) return;
+    if ((e.target as HTMLElement).closest('.sh3-float-popout')) return;
     floatManager.toggleMaximize(entry.id);
   }
 
@@ -176,6 +183,25 @@
     e.stopPropagation();
     floatManager.close(entry.id);
   }
+
+  async function onPopOut(e: MouseEvent): Promise<void> {
+    e.stopPropagation();
+    try {
+      await spawnSatellite({
+        kind: 'float',
+        content: entry.content,
+        title: entry.title,
+        size: { w: entry.size.w, h: entry.size.h },
+        activateShards: walkShardsForContent(entry.content),
+      });
+      floatManager.close(entry.id);
+    } catch (err) {
+      shell.toast.notify(
+        `Pop-out failed: ${(err as Error).message}`,
+        { level: 'error', duration: 5000 },
+      );
+    }
+  }
 </script>
 
 <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
@@ -208,6 +234,14 @@
     >
       <span class="sh3-float-title">{entry.title}</span>
       <span class="sh3-float-header-actions">
+        {#if isTauri}
+          <button
+            class="sh3-float-popout"
+            onclick={onPopOut}
+            aria-label="Open in own window"
+            title="Open in own window"
+          >⧉</button>
+        {/if}
         <button
           class="sh3-float-maximize"
           onclick={onMaximize}
@@ -271,6 +305,7 @@
     gap: 2px;
     flex-shrink: 0;
   }
+  .sh3-float-popout,
   .sh3-float-maximize,
   .sh3-float-close {
     background: transparent;
@@ -280,6 +315,7 @@
     cursor: pointer;
     padding: 0 4px;
   }
+  .sh3-float-popout,
   .sh3-float-maximize {
     font-size: 12px;
   }

package/dist/runtime/runVerb-shell.test.js

@@ -29,26 +29,6 @@ describe('shell-shard programmatic verbs (integration)', () => {
         registerShard(shellShard);
         await activateShard('shell');
     });
-    // ── pure text verbs ────────────────────────────────────────────────────
-    it('pwd emits a single text entry with the cwd', async () => {
-        const out = await runVerbProgrammatic('shell', 'pwd', []);
-        expect(out.result).toBeUndefined();
-        expect(out.scrollback).toHaveLength(1);
-        const entry = out.scrollback[0];
-        expect(entry.kind).toBe('text');
-        if (entry.kind !== 'text')
-            throw new Error('unreachable');
-        expect(entry.stream).toBe('stdout');
-        expect(entry.chunks.join('')).toMatch(/^\/.*\n$/);
-    });
-    it('whoami emits a text entry with the user id', async () => {
-        const out = await runVerbProgrammatic('shell', 'whoami', []);
-        const entry = out.scrollback[0];
-        expect(entry.kind).toBe('text');
-        if (entry.kind !== 'text')
-            throw new Error('unreachable');
-        expect(entry.chunks.join('')).toMatch(/guest/);
-    });
     // ── rich-entry introspection verbs ─────────────────────────────────────
     it('apps emits a rich entry whose props.data.apps is an array', async () => {
         const out = await runVerbProgrammatic('shell', 'apps', []);
@@ -209,23 +189,4 @@ describe('shell-shard programmatic verbs (integration)', () => {
             throw new Error('unreachable');
         expect(entry.text).toMatch(/no active floats/);
     });
-    // ── fs verbs (no server in test → error path) ──────────────────────────
-    it('cat with no args emits a missing-argument error', async () => {
-        const out = await runVerbProgrammatic('shell', 'cat', []);
-        const entry = out.scrollback[0];
-        expect(entry.kind).toBe('status');
-        if (entry.kind !== 'status')
-            throw new Error('unreachable');
-        expect(entry.level).toBe('error');
-        expect(entry.text).toMatch(/missing file argument/);
-    });
-    it('ls without an fs backend emits an error status (does not throw)', async () => {
-        const out = await runVerbProgrammatic('shell', 'ls', []);
-        expect(out.scrollback).toHaveLength(1);
-        const entry = out.scrollback[0];
-        // Either a real text response (unlikely in test) or an error status —
-        // we only commit to the contract that the verb pushes exactly one entry
-        // and never throws.
-        expect(['text', 'status']).toContain(entry.kind);
-    });
 });

package/dist/runtime/runVerb.test.js

@@ -129,4 +129,21 @@ describe('runVerbProgrammatic', () => {
         await activateShard('tester');
         await expect(runVerbProgrammatic('tester', 'tester:boom', [])).rejects.toThrow('kaboom');
     });
+    it('exposes vctx.shell.dispatchToTerminal that returns no-active-context', async () => {
+        let observed = undefined;
+        registerShard({
+            manifest: { id: 'tester', label: 'T', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(makeVerb('peek-shell', true, async (vctx) => {
+                    observed = vctx.shell.dispatchToTerminal('foo');
+                }));
+            },
+        });
+        await activateShard('tester');
+        await runVerbProgrammatic('tester', 'tester:peek-shell', []);
+        expect(observed).toMatchObject({
+            ok: false,
+            error: 'no-active-context',
+        });
+    });
 });

package/dist/satellite/SatelliteShell.svelte

@@ -0,0 +1,60 @@
+<script lang="ts">
+  /*
+   * SatelliteShell — top-level root component mounted by createShell() when
+   * detectSatelliteMode() returns a payload.
+   *
+   * Renders only LayoutRenderer against the seeded in-memory layout. No brand
+   * bar, no home button, no overlay chrome. The workspace zone backend has
+   * already been forced to MemoryBackend by createShell() before this mounts.
+   *
+   * Float payloads: seeds HOME_TREE's docked node directly via
+   *   seedSatelliteLayout(), so LayoutRenderer immediately shows the detached
+   *   float content.
+   *
+   * App payloads: kicks off launchApp(appId, { skipLastApp, skipSwitchToHome })
+   *   which handles the full attach/switchToApp lifecycle. The seed call is
+   *   skipped because launchApp replaces the active root to 'app' on its own.
+   */
+
+  import '../tokens.css';
+  import '../primitives/base.css';
+  import LayoutRenderer from '../layout/LayoutRenderer.svelte';
+  import { seedSatelliteLayout } from '../layout/store.svelte';
+  import { seedLayoutFromPayload } from './seed';
+  import { launchApp } from '../apps/lifecycle';
+  import type { SatellitePayload } from '../boot/satellitePayload';
+
+  interface Props {
+    payload: SatellitePayload;
+  }
+  let { payload }: Props = $props();
+
+  // The payload is a one-shot prop set at spawn time and never reassigned.
+  // We read it inside $effect to make the one-time-read intent explicit
+  // (silences state_referenced_locally) and to defer side-effects past the
+  // script's synchronous evaluation phase.
+  $effect(() => {
+    if (payload.kind === 'float') {
+      seedSatelliteLayout(seedLayoutFromPayload(payload).docked);
+    } else if (payload.kind === 'app') {
+      const appId = payload.appId;
+      queueMicrotask(() => {
+        void launchApp(appId, { skipLastApp: true, skipSwitchToHome: true });
+      });
+    }
+  });
+</script>
+
+<div class="sh3-satellite-root">
+  <LayoutRenderer />
+</div>
+
+<style>
+  .sh3-satellite-root {
+    position: absolute;
+    inset: 0;
+    overflow: hidden;
+    background: var(--shell-grad-bg, var(--shell-bg));
+    color: var(--shell-fg);
+  }
+</style>

package/dist/satellite/SatelliteShell.svelte.d.ts

@@ -0,0 +1,9 @@
+import '../tokens.css';
+import '../primitives/base.css';
+import type { SatellitePayload } from '../boot/satellitePayload';
+interface Props {
+    payload: SatellitePayload;
+}
+declare const SatelliteShell: import("svelte").Component<Props, {}, "">;
+type SatelliteShell = ReturnType<typeof SatelliteShell>;
+export default SatelliteShell;

package/dist/satellite/seed.d.ts

@@ -0,0 +1,3 @@
+import type { LayoutTree } from '../layout/types';
+import type { SatellitePayload } from '../boot/satellitePayload';
+export declare function seedLayoutFromPayload(payload: SatellitePayload): LayoutTree;

package/dist/satellite/seed.js

@@ -0,0 +1,20 @@
+/*
+ * seedLayoutFromPayload — produce the initial LayoutTree the satellite
+ * mounts. Float payloads use the supplied content tree directly as the
+ * docked root. App payloads start with a single empty slot (viewId: null)
+ * that the launched app fills via the normal attachApp lifecycle.
+ */
+export function seedLayoutFromPayload(payload) {
+    if (payload.kind === 'float') {
+        return {
+            docked: payload.content,
+            floats: [],
+        };
+    }
+    // App payload: empty slot — attachApp will replace it.
+    const root = { type: 'slot', slotId: 'satellite:root', viewId: null };
+    return {
+        docked: root,
+        floats: [],
+    };
+}

package/dist/satellite/seed.test.d.ts

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

package/dist/satellite/seed.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { seedLayoutFromPayload } from './seed';
+describe('seedLayoutFromPayload', () => {
+    it('seeds a float payload with content as the docked root', () => {
+        const content = { type: 'slot', slotId: 's:1', viewId: 'a:v' };
+        const payload = {
+            kind: 'float',
+            content,
+            title: 'X',
+            size: { w: 800, h: 600 },
+            activateShards: ['a'],
+        };
+        const tree = seedLayoutFromPayload(payload);
+        expect(tree.docked).toEqual(content);
+        expect(tree.floats).toEqual([]);
+    });
+    it('seeds an app payload with an empty slot the app will fill', () => {
+        const payload = {
+            kind: 'app',
+            appId: 'sh3-store',
+            activateShards: ['sh3-store'],
+        };
+        const tree = seedLayoutFromPayload(payload);
+        expect(tree.docked.type).toBe('slot');
+        expect(tree.floats).toEqual([]);
+    });
+    it('seeds an app payload with a null viewId on the empty slot', () => {
+        const payload = {
+            kind: 'app',
+            appId: 'sh3-store',
+            activateShards: ['sh3-store'],
+        };
+        const tree = seedLayoutFromPayload(payload);
+        if (tree.docked.type !== 'slot')
+            throw new Error('expected slot');
+        expect(tree.docked.viewId).toBeNull();
+    });
+});

package/dist/satellite/walkShards.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutNode } from '../layout/types';
+export declare function walkShardsForContent(node: LayoutNode): string[];

package/dist/satellite/walkShards.js

@@ -0,0 +1,44 @@
+/*
+ * walkShardsForContent — given a LayoutNode tree (typically from a float's
+ * content), return the deduplicated list of shardIds providing the slot
+ * views inside it. Used at spawn time to compute the satellite's
+ * activateShards list.
+ *
+ * Slots whose viewId is null or has no registered provider are silently
+ * skipped — the satellite will surface a "Required shard X missing" error
+ * if it encounters an unrenderable slot during mount.
+ */
+import { getShardForView } from '../shards/registry';
+export function walkShardsForContent(node) {
+    const acc = new Set();
+    walk(node, acc);
+    return [...acc];
+}
+function walk(node, acc) {
+    switch (node.type) {
+        case 'slot': {
+            if (node.viewId !== null) {
+                const shardId = getShardForView(node.viewId);
+                if (shardId)
+                    acc.add(shardId);
+            }
+            return;
+        }
+        case 'tabs': {
+            for (const tab of node.tabs) {
+                if (tab.viewId !== null) {
+                    const shardId = getShardForView(tab.viewId);
+                    if (shardId)
+                        acc.add(shardId);
+                }
+            }
+            return;
+        }
+        case 'split': {
+            for (const child of node.children) {
+                walk(child, acc);
+            }
+            return;
+        }
+    }
+}

package/dist/satellite/walkShards.test.d.ts

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

package/dist/satellite/walkShards.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registerView, __resetViewRegistryForTest, } from '../shards/registry';
+import { walkShardsForContent } from './walkShards';
+const mountStub = () => ({ unmount: () => { } });
+beforeEach(() => {
+    __resetViewRegistryForTest();
+});
+describe('walkShardsForContent', () => {
+    it('returns empty array for a slot with an unregistered view', () => {
+        const node = { type: 'slot', slotId: 's', viewId: 'unknown:v' };
+        expect(walkShardsForContent(node)).toEqual([]);
+    });
+    it('returns the providing shard for a single registered slot', () => {
+        registerView('alpha:v', { mount: mountStub }, 'alpha');
+        const node = { type: 'slot', slotId: 's', viewId: 'alpha:v' };
+        expect(walkShardsForContent(node)).toEqual(['alpha']);
+    });
+    it("walks tabs nodes and collects each tab's shard", () => {
+        registerView('a:v', { mount: mountStub }, 'a');
+        registerView('b:v', { mount: mountStub }, 'b');
+        const node = {
+            type: 'tabs',
+            tabs: [
+                { slotId: 't1', viewId: 'a:v', label: 'A' },
+                { slotId: 't2', viewId: 'b:v', label: 'B' },
+            ],
+            activeTab: 0,
+        };
+        expect(walkShardsForContent(node).sort()).toEqual(['a', 'b']);
+    });
+    it('walks split nodes recursively', () => {
+        registerView('x:v', { mount: mountStub }, 'x');
+        registerView('y:v', { mount: mountStub }, 'y');
+        const node = {
+            type: 'split',
+            direction: 'horizontal',
+            children: [
+                { type: 'slot', slotId: 's1', viewId: 'x:v' },
+                {
+                    type: 'split',
+                    direction: 'vertical',
+                    children: [
+                        { type: 'slot', slotId: 's2', viewId: 'y:v' },
+                        { type: 'slot', slotId: 's3', viewId: 'x:v' },
+                    ],
+                    sizes: [0.5, 0.5],
+                },
+            ],
+            sizes: [0.5, 0.5],
+        };
+        expect(walkShardsForContent(node).sort()).toEqual(['x', 'y']);
+    });
+    it('dedupes when multiple slots share the same shard', () => {
+        registerView('z:v', { mount: mountStub }, 'z');
+        const node = {
+            type: 'tabs',
+            tabs: [
+                { slotId: 't1', viewId: 'z:v', label: 'A' },
+                { slotId: 't2', viewId: 'z:v', label: 'B' },
+            ],
+            activeTab: 0,
+        };
+        expect(walkShardsForContent(node)).toEqual(['z']);
+    });
+});

package/dist/sh3core-shard/appActions.js

@@ -27,6 +27,10 @@ import { toastManager } from '../overlays/toast';
 import AppUpdateAvailableModal from '../app/store/AppUpdateAvailableModal.svelte';
 import UninstallAppDialog from '../app/store/UninstallAppDialog.svelte';
 import AppInfoView from './AppInfoView.svelte';
+import { spawnSatellite } from '../shellApi/window';
+import { activeApp, getActiveApp } from '../apps/registry.svelte';
+import { returnToHome } from '../apps/lifecycle';
+const isTauri = typeof globalThis.__TAURI_INTERNALS__ !== 'undefined';
 export function computeAppActionDisabled(g) {
     return !g.admin || g.builtin;
 }
@@ -106,6 +110,34 @@ async function runCheckUpdate(_ctx) {
     };
     modalManager.open(AppUpdateAvailableModal, props);
 }
+function runPopOut(_ctx) {
+    var _a;
+    const ref = readSelection();
+    if (!ref)
+        return;
+    const manifest = findApp(ref.appId);
+    if (!manifest)
+        return;
+    void spawnSatellite({
+        kind: 'app',
+        appId: ref.appId,
+        activateShards: (_a = manifest.requiredShards) !== null && _a !== void 0 ? _a : [],
+    });
+}
+async function runPopOutCurrent(_ctx) {
+    var _a;
+    const current = getActiveApp();
+    if (!current)
+        return;
+    const appId = current.id;
+    const requiredShards = (_a = current.requiredShards) !== null && _a !== void 0 ? _a : [];
+    await returnToHome();
+    void spawnSatellite({
+        kind: 'app',
+        appId,
+        activateShards: requiredShards,
+    });
+}
 function runUninstall(_ctx) {
     var _a, _b;
     const ref = readSelection();
@@ -193,6 +225,25 @@ export function registerAppActions(ctx) {
             disabled: isDisabledForCurrent,
             run: runUninstall,
         },
+        {
+            id: 'app.popout',
+            label: 'Open in standalone view',
+            scope: { element: 'app' },
+            contextItem: true,
+            paletteItem: false,
+            group: 'window',
+            disabled: () => !isTauri,
+            run: runPopOut,
+        },
+        {
+            id: 'app.popoutCurrent',
+            label: 'Pop out current app',
+            scope: 'app',
+            contextItem: false,
+            paletteItem: true,
+            disabled: () => !isTauri || activeApp.id == null,
+            run: runPopOutCurrent,
+        },
     ];
     const disposers = actions.map((a) => ctx.actions.register(a));
     return () => disposers.forEach((d) => d());

package/dist/shards/activate.svelte.d.ts

@@ -18,7 +18,7 @@ export declare const activeShards: Map<string, Shard>;
 export interface ShardErrorEntry {
     id: string;
     error: unknown;
-    phase: 'autostart' | 'launch';
+    phase: 'autostart' | 'launch' | 'satellite';
     timestamp: number;
 }
 export declare const erroredShards: Map<string, ShardErrorEntry>;
@@ -39,7 +39,7 @@ export interface ActivateShardOpts {
      * recorded in `erroredShards` if activation fails. Defaults to 'launch'
      * (the common case — required by an app being launched).
      */
-    phase?: 'autostart' | 'launch';
+    phase?: 'autostart' | 'launch' | 'satellite';
 }
 /**
  * Activate a registered shard. Builds a `ShardContext`, calls `shard.activate`,

package/dist/shards/activate.svelte.js

@@ -134,7 +134,7 @@ export async function activateShard(id, opts) {
     const ctx = {
         state: (schema) => shell.state(id, schema),
         registerView: (viewId, factory) => {
-            registerView(viewId, factory);
+            registerView(viewId, factory, shard.manifest.id);
             entry.viewIds.add(viewId);
         },
         registerVerb: (verb) => {

package/dist/shards/registry.d.ts

@@ -1,8 +1,9 @@
 import type { ViewFactory } from './types';
 export declare function __addViewRegistrationListener(fn: (viewId: string, factory: ViewFactory) => void): void;
 export declare function __removeViewRegistrationListener(fn: (viewId: string, factory: ViewFactory) => void): void;
-export declare function registerView(viewId: string, factory: ViewFactory): void;
+export declare function registerView(viewId: string, factory: ViewFactory, shardId?: string): void;
 export declare function getView(viewId: string): ViewFactory | undefined;
+export declare function getShardForView(viewId: string): string | undefined;
 export declare function unregisterView(viewId: string): void;
 import type { Verb } from '../verbs/types';
 export declare function registerVerb(name: string, verb: Verb, shardId: string): void;

package/dist/shards/registry.js

@@ -1,9 +1,9 @@
 /*
  * Contribution registry — views and verbs.
  *
- * Tracks which ViewFactory answers a given viewId. In this phase the
- * registry is a flat module-level Map with no awareness of shard identity;
- * writes come from `activateShard` which additionally remembers which
+ * Tracks which ViewFactory answers a given viewId and, via the `viewToShard`
+ * reverse map, which shard owns each view (queryable through `getShardForView`).
+ * Writes come from `activateShard` which additionally remembers which
  * viewIds a given shard registered so they can be torn down in
  * `deactivateShard`.
  *
@@ -14,6 +14,7 @@
  *     hotkeys get their own sibling maps when those kinds land.
  */
 const views = new Map();
+const viewToShard = new Map();
 /** Listeners called after a new view factory is registered. */
 const viewRegistrationListeners = new Set();
 export function __addViewRegistrationListener(fn) {
@@ -22,11 +23,14 @@ export function __addViewRegistrationListener(fn) {
 export function __removeViewRegistrationListener(fn) {
     viewRegistrationListeners.delete(fn);
 }
-export function registerView(viewId, factory) {
+export function registerView(viewId, factory, shardId) {
     if (views.has(viewId)) {
         throw new Error(`View "${viewId}" is already registered`);
     }
     views.set(viewId, factory);
+    if (shardId !== undefined) {
+        viewToShard.set(viewId, shardId);
+    }
     for (const listener of viewRegistrationListeners) {
         listener(viewId, factory);
     }
@@ -34,8 +38,12 @@ export function registerView(viewId, factory) {
 export function getView(viewId) {
     return views.get(viewId);
 }
+export function getShardForView(viewId) {
+    return viewToShard.get(viewId);
+}
 export function unregisterView(viewId) {
     views.delete(viewId);
+    viewToShard.delete(viewId);
 }
 const verbs = new Map();
 export function registerVerb(name, verb, shardId) {
@@ -68,6 +76,7 @@ export function listVerbsWithShard() {
 /** Test-only reset: clear the view and verb registries. */
 export function __resetViewRegistryForTest() {
     views.clear();
+    viewToShard.clear();
     verbs.clear();
     // Do NOT clear viewRegistrationListeners — they are module-level subscriptions
     // (e.g. slotHostPool's late-factory listener) that must survive registry resets.

package/dist/shards/registry.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { registerVerb, getVerb, unregisterVerb, listVerbs, listVerbsWithShard, } from './registry';
+import { registerVerb, getVerb, unregisterVerb, listVerbs, listVerbsWithShard, registerView, unregisterView, getShardForView, __resetViewRegistryForTest, } from './registry';
 function makeStubVerb(name) {
     return { name, summary: `stub ${name}`, run: async () => { } };
 }
@@ -68,3 +68,24 @@ describe('verb registry', () => {
         expect(listVerbsWithShard()).toHaveLength(0);
     });
 });
+describe('getShardForView (reverse index)', () => {
+    beforeEach(() => __resetViewRegistryForTest());
+    it('returns undefined for an unregistered view', () => {
+        expect(getShardForView('nope:never')).toBeUndefined();
+    });
+    it('returns the shard id passed at registration time', () => {
+        registerView('test:rv1', { mount: () => ({ unmount: () => { } }) }, 'shardA');
+        expect(getShardForView('test:rv1')).toBe('shardA');
+        unregisterView('test:rv1');
+    });
+    it('returns undefined if registered without a shard id (legacy callers)', () => {
+        registerView('test:rv2', { mount: () => ({ unmount: () => { } }) });
+        expect(getShardForView('test:rv2')).toBeUndefined();
+        unregisterView('test:rv2');
+    });
+    it('clears the reverse entry on unregisterView', () => {
+        registerView('test:rv3', { mount: () => ({ unmount: () => { } }) }, 'shardB');
+        unregisterView('test:rv3');
+        expect(getShardForView('test:rv3')).toBeUndefined();
+    });
+});

package/dist/shards/types.d.ts

@@ -181,6 +181,7 @@ export interface ShardContext {
     /**
      * Register a view factory for a view id declared in the shard manifest.
      * Must be called for every id listed in `manifest.views` during `activate`.
+     * The shard id is injected automatically by the shell — shards do not need to pass it.
      *
      * @param viewId  - Must match an entry in `manifest.views`.
      * @param factory - The adapter that mounts the view into a container element.

package/dist/shell-shard/CommandLine.svelte

@@ -22,6 +22,7 @@
     disabled?: boolean;
     name?: string;
     onkeydown?: (e: KeyboardEvent) => void;
+    onfocus?: (e: FocusEvent) => void;
   }
   let {
     value = $bindable(''),
@@ -29,6 +30,7 @@
     disabled = false,
     name,
     onkeydown,
+    onfocus,
   }: Props = $props();
 
   let input: HTMLInputElement | null = $state(null);
@@ -72,6 +74,7 @@
     {name}
     {disabled}
     onkeydown={handleKeyDown}
+    onfocus={onfocus}
     spellcheck="false"
     autocomplete="off"
     autocapitalize="off"

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

@@ -20,6 +20,7 @@ interface Props {
     disabled?: boolean;
     name?: string;
     onkeydown?: (e: KeyboardEvent) => void;
+    onfocus?: (e: FocusEvent) => void;
 }
 declare const CommandLine: import("svelte").Component<Props, {}, "value">;
 type CommandLine = ReturnType<typeof CommandLine>;