sh3-core 0.15.1 → 0.15.2

package/dist/{app-appearance/AppAppearanceModal.svelte → overlays/EntityAppearanceModal.svelte}

@@ -1,58 +1,65 @@
 <script lang="ts">
   /*
-   * Customize — pick an icon and color override for a single app.
-   * Reads the existing override on mount via untrack (Svelte 5 idiom for
-   * one-shot prop reads), so editing the form doesn't subscribe to the
-   * shard's reactive state. Save/Reset/Cancel are mutually exclusive.
+   * EntityAppearanceModal — generalization of the per-entity Customize
+   * modal. Used by __app-appearance__ for apps and __layouts__ for saved
+   * layouts. Purely presentational: callers pass an
+   * onSave({ label, icon, color }) callback and decide what an empty
+   * label means (apps treat empty as "use manifest"; layouts mark the
+   * input required via requireLabel: true).
    */
 
   import { untrack } from 'svelte';
   import IconPicker from '../primitives/widgets/IconPicker.svelte';
   import ColorSwatch from '../primitives/widgets/ColorSwatch.svelte';
   import iconsUrl from '../assets/icons.svg';
-  import { listRegisteredApps } from '../api';
-  import { getAppearance, setAppearance } from './appearanceState.svelte';
 
   interface Props {
-    appId: string;
-    appLabel: string;
+    entityLabel: string;
+    initialAppearance?: { icon?: string; color?: string };
+    defaultIcon: string;
+    requireLabel: boolean;
+    onSave(next: { label: string; icon?: string; color?: string }): void;
+    onReset(): void;
     close: () => void;
   }
 
-  let { appId, appLabel, close }: Props = $props();
+  let {
+    entityLabel,
+    initialAppearance,
+    defaultIcon,
+    requireLabel,
+    onSave,
+    onReset,
+    close,
+  }: Props = $props();
 
-  const initial = untrack(() => getAppearance(appId));
-  const manifestIcon = untrack(
-    () => listRegisteredApps().find((m) => m.id === appId)?.icon,
-  );
+  const initial = untrack(() => initialAppearance);
 
   let icon = $state<string | undefined>(initial?.icon);
   let color = $state<string | undefined>(initial?.color);
-  let label = $state<string>(initial?.label ?? '');
+  let label = $state<string>(untrack(() => entityLabel));
   let pickerOpen = $state<boolean>(initial?.icon !== undefined);
 
+  const trimmed = $derived(label.trim());
+  const saveDisabled = $derived(requireLabel && trimmed === '');
+  const effectiveLabel = $derived(trimmed === '' ? entityLabel : trimmed);
+  const effectiveIcon = $derived(icon ?? defaultIcon);
   const hasOverride = $derived(initial !== undefined);
-  const effectiveLabel = $derived(label.trim() === '' ? appLabel : label.trim());
-  const effectiveIcon = $derived(icon ?? manifestIcon ?? 'box');
 
   function save() {
-    const trimmed = label.trim();
-    setAppearance(appId, {
-      icon,
-      color,
-      label: trimmed === '' ? undefined : trimmed,
-    });
+    if (saveDisabled) return;
+    onSave({ label: trimmed, icon, color });
     close();
   }
 
   function reset() {
-    setAppearance(appId, undefined);
+    onReset();
     close();
   }
 </script>
 
 <div class="app-appearance">
-  <h2>Customize {appLabel}</h2>
+  <h2>Customize {entityLabel}</h2>
 
   <div class="preview">
     <div
@@ -67,11 +74,11 @@
     </div>
   </div>
 
-  <label class="row"><span>Name <em>(empty = default)</em></span>
+  <label class="row"><span>Name {#if !requireLabel}<em>(empty = default)</em>{/if}</span>
     <input
       type="text"
       bind:value={label}
-      placeholder={appLabel}
+      placeholder={entityLabel}
       class="name-input"
     />
   </label>
@@ -95,9 +102,9 @@
   </label>
 
   <div class="actions">
-    <button type="button" class="primary" onclick={save}>Save</button>
-    <button type="button" onclick={reset} disabled={!hasOverride}>Reset</button>
-    <button type="button" onclick={close}>Cancel</button>
+    <button type="button" class="primary" onclick={save} disabled={saveDisabled}>Save</button>
+    <button type="button" data-role="reset" onclick={reset} disabled={!hasOverride}>Reset</button>
+    <button type="button" onclick={() => close()}>Cancel</button>
   </div>
 </div>
 
@@ -158,8 +165,6 @@
     -webkit-line-clamp: 2;
     line-clamp: 2;
   }
-  .preview-card-icon { width: 24px; height: 24px; color: var(--shell-fg); }
-  .preview-card-label { font-weight: 600; padding: 0 4px; line-height: 1.2; }
   .actions { display: flex; gap: 8px; margin-top: 16px; }
   .actions button {
     background: var(--shell-bg-elevated);

package/dist/overlays/EntityAppearanceModal.svelte.d.ts

@@ -0,0 +1,19 @@
+interface Props {
+    entityLabel: string;
+    initialAppearance?: {
+        icon?: string;
+        color?: string;
+    };
+    defaultIcon: string;
+    requireLabel: boolean;
+    onSave(next: {
+        label: string;
+        icon?: string;
+        color?: string;
+    }): void;
+    onReset(): void;
+    close: () => void;
+}
+declare const EntityAppearanceModal: import("svelte").Component<Props, {}, "">;
+type EntityAppearanceModal = ReturnType<typeof EntityAppearanceModal>;
+export default EntityAppearanceModal;

package/dist/overlays/EntityAppearanceModal.test.d.ts

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

package/dist/overlays/EntityAppearanceModal.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mount, flushSync } from 'svelte';
+import EntityAppearanceModal from './EntityAppearanceModal.svelte';
+function mountModal(props = {}) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    const onSave = vi.fn();
+    const onReset = vi.fn();
+    const close = vi.fn();
+    const instance = mount(EntityAppearanceModal, {
+        target,
+        props: Object.assign({ entityLabel: 'My App', defaultIcon: 'box', requireLabel: false, onSave,
+            onReset,
+            close }, props),
+    });
+    return { target, onSave, onReset, close, instance };
+}
+describe('EntityAppearanceModal', () => {
+    it('renders the entityLabel as title placeholder', () => {
+        const { target } = mountModal();
+        const input = target.querySelector('input.name-input');
+        expect(input.placeholder).toBe('My App');
+    });
+    it('shows the "(empty = default)" hint when requireLabel is false', () => {
+        const { target } = mountModal({ requireLabel: false });
+        expect(target.textContent).toContain('(empty = default)');
+    });
+    it('hides the "(empty = default)" hint when requireLabel is true', () => {
+        const { target } = mountModal({ requireLabel: true });
+        expect(target.textContent).not.toContain('(empty = default)');
+    });
+    it('disables Save when requireLabel is true and the input is empty', async () => {
+        const { target } = mountModal({ requireLabel: true, entityLabel: '' });
+        flushSync();
+        const save = target.querySelector('button.primary');
+        expect(save.disabled).toBe(true);
+    });
+    it('calls onSave with the trimmed label, icon, color', async () => {
+        const { target, onSave } = mountModal({
+            initialAppearance: { icon: 'cog', color: '#ff0000' },
+        });
+        const input = target.querySelector('input.name-input');
+        input.value = '  Renamed  ';
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        flushSync();
+        target.querySelector('button.primary').click();
+        expect(onSave).toHaveBeenCalledWith({ label: 'Renamed', icon: 'cog', color: '#ff0000' });
+    });
+    it('calls onReset and close when Reset is clicked', async () => {
+        const { target, onReset, close } = mountModal({
+            initialAppearance: { icon: 'cog' },
+        });
+        target.querySelector('button[data-role="reset"]').click();
+        expect(onReset).toHaveBeenCalled();
+        expect(close).toHaveBeenCalled();
+    });
+});

package/dist/overlays/FloatFrame.svelte

@@ -31,6 +31,20 @@
   import { registerDismissableFrame, unregisterDismissableFrame } from './floatDismiss';
   import { computeMinSize } from '../layout/floats';
   import type { FloatEntry } from '../layout/types';
+  import { shell } from '../shellRuntime.svelte';
+  import { makeSelectionApi } from '../actions/selection.svelte';
+
+  const floatHeaderSelection = makeSelectionApi('__layouts__');
+
+  function openHeaderContextMenu(e: MouseEvent): void {
+    e.preventDefault();
+    floatHeaderSelection.set({ type: 'float-header', ref: { floatId: entry.id } });
+    shell.actions.openContextMenu({
+      x: e.clientX,
+      y: e.clientY,
+      scope: { element: 'float-header' },
+    });
+  }
 
   interface Props {
     entry: FloatEntry;
@@ -183,11 +197,14 @@
     <!-- svelte-ignore a11y_no_static_element_interactions -->
     <header
       class="sh3-float-header"
+      data-sh3-scope="element:float-header"
+      data-float-id={entry.id}
       onpointerdown={onHeaderPointerDown}
       onpointermove={onHeaderPointerMove}
       onpointerup={onHeaderPointerUp}
       onpointercancel={onHeaderPointerUp}
       ondblclick={onHeaderDblClick}
+      oncontextmenu={openHeaderContextMenu}
     >
       <span class="sh3-float-title">{entry.title}</span>
       <span class="sh3-float-header-actions">

package/dist/overlays/float.d.ts

@@ -1,4 +1,4 @@
-import type { FloatEntry } from '../layout/types';
+import type { LayoutNode, FloatEntry } from '../layout/types';
 import type { Size } from '../layout/floats';
 export interface FloatOptions {
     title?: string;
@@ -29,6 +29,22 @@ export interface FloatOptions {
 }
 export interface FloatManager {
     open(viewId: string, options?: FloatOptions): string;
+    /**
+     * Open a float with a pre-built content tree. Used by save/restore flows
+     * (e.g. saved layouts) where the caller has already arranged the
+     * structure rather than starting from a single view id. The `content`
+     * tree is stored verbatim — the caller is responsible for cloning if it
+     * shouldn't be aliased to a source.
+     */
+    openWithContent(options: {
+        content: LayoutNode;
+        size: Size;
+        title?: string;
+        position?: {
+            x: number;
+            y: number;
+        };
+    }): string;
     close(floatId: string): void;
     list(): FloatEntry[];
     focus(floatId: string): void;

package/dist/overlays/float.js

@@ -137,6 +137,21 @@ function openFloat(viewId, options = {}) {
     store.push(entry);
     return id;
 }
+function openFloatWithContent(options) {
+    var _a;
+    const store = activeStore();
+    const id = generateFloatId();
+    const position = (_a = options.position) !== null && _a !== void 0 ? _a : cascadePosition(store, getTreeBounds());
+    const entry = {
+        id,
+        content: options.content,
+        position,
+        size: options.size,
+        title: options.title,
+    };
+    store.push(entry);
+    return id;
+}
 function closeFloat(floatId) {
     const store = activeStore();
     const idx = store.findIndex((f) => f.id === floatId);
@@ -211,6 +226,7 @@ function isMaximizedFloat(id) {
 }
 export const floatManager = {
     open: openFloat,
+    openWithContent: openFloatWithContent,
     close: closeFloat,
     list: listFloats,
     focus: focusFloat,

package/dist/overlays/float.test.js

@@ -836,3 +836,38 @@ describe('floats — F.20 dismissable + grip', () => {
         expect(floatManager.list().some((f) => f.id === id)).toBe(true);
     });
 });
+describe('floatManager.openWithContent', () => {
+    beforeEach(() => __resetFloatManagerForTest());
+    it('opens a float whose entry.content equals the supplied tree', () => {
+        const content = {
+            type: 'tabs',
+            activeTab: 0,
+            tabs: [{ slotId: 'restored:1', viewId: 'shell:terminal', label: 'Shell' }],
+        };
+        const id = floatManager.openWithContent({
+            content,
+            size: { w: 700, h: 500 },
+            title: 'My Layout',
+        });
+        const list = floatManager.list();
+        expect(list).toHaveLength(1);
+        expect(list[0].id).toBe(id);
+        expect(list[0].content).toEqual(content);
+        expect(list[0].size).toEqual({ w: 700, h: 500 });
+        expect(list[0].title).toBe('My Layout');
+    });
+    it('uses the cascade default position when not given one', () => {
+        const content = {
+            type: 'slot',
+            slotId: 'restored:2',
+            viewId: 'shell:terminal',
+        };
+        const id = floatManager.openWithContent({
+            content,
+            size: { w: 600, h: 400 },
+        });
+        const entry = floatManager.list().find((f) => f.id === id);
+        expect(typeof entry.position.x).toBe('number');
+        expect(typeof entry.position.y).toBe('number');
+    });
+});

package/dist/sh3core-shard/ShellHome.svelte

@@ -10,6 +10,7 @@
   import { listRegisteredApps, launchApp, isAdmin, VERSION } from '../api';
   import ShellTitle from './ShellTitle.svelte';
   import ProjectsSection from '../projects-shard/ProjectsSection.svelte';
+  import LayoutsSection from '../layouts-shard/LayoutsSection.svelte';
   import { sessionState } from '../projects/session-state.svelte';
   import { projectsState } from '../projects-shard/projectsShard.svelte';
   import { shell } from '../shellRuntime.svelte';
@@ -82,6 +83,8 @@
 
   <ProjectsSection />
 
+  <LayoutsSection />
+
   {#if userApps.length > 0}
     <section class="shell-home-section">
       <h2 class="shell-home-section-title">Apps</h2>

package/dist/shards/activate.svelte.js

@@ -30,9 +30,11 @@ import { createShardKeysApi } from '../keys/client';
 import { PERMISSION_KEYS_MINT } from '../keys/types';
 import { subscribe } from '../keys/revocation-bus.svelte';
 import { register as contributionsRegister, list as contributionsList, listPoints as contributionsListPoints, onChange as contributionsOnChange, onAnyChange as contributionsOnAnyChange, } from '../contributions';
-import { registerAction } from '../actions/registry';
+import { registerAction, listActions as listActionsFromRegistry } from '../actions/registry';
 import { makeSelectionApi, clearSelectionForShard } from '../actions/selection.svelte';
-import { openContextMenu as shellOpenContextMenu, openPalette as shellOpenPalette } from '../actions/listeners';
+import { openContextMenu as shellOpenContextMenu, openPalette as shellOpenPalette, dispatchActionProgrammatic, } from '../actions/listeners';
+import { listActionsFromEntries } from '../actions/listActive';
+import { getLiveDispatcherState } from '../actions/state.svelte';
 /**
  * Reactive registry of every shard known to the host. Keys are shard ids.
  * Populated once at boot by the glob-discovery loop in main.ts (through
@@ -217,6 +219,13 @@ export async function activateShard(id, opts) {
         runVerb(shardId, name, args, opts) {
             return runVerbProgrammatic(shardId, name, args, opts);
         },
+        listActions(opts) {
+            const all = listActionsFromEntries(listActionsFromRegistry(), getLiveDispatcherState());
+            return (opts === null || opts === void 0 ? void 0 : opts.activeOnly) ? all.filter((a) => a.active) : all;
+        },
+        runAction(actionId, opts) {
+            return dispatchActionProgrammatic(actionId, opts);
+        },
     };
     entry.ctx = ctx;
     // Wire onKeyRevoked hook: subscribe to the revocation bus for this shard.

package/dist/shards/types.d.ts

@@ -7,7 +7,7 @@ import type { Verb, VerbSchema } from '../verbs/types';
 import type { ScrollbackEntry } from '../shell-shard/scrollback.svelte';
 import type { ShardContextKeys } from '../keys/types';
 import type { ContributionsApi } from '../contributions/types';
-import type { ActionsApi } from '../actions/types';
+import type { ActionsApi, ActionDescriptor } from '../actions/types';
 import type { TreeRootRef } from '../layout/types';
 export { PERMISSION_KEYS_MINT, type ShardContextKeys, type ApiKeyPublic, type MintOpts, ScopeEscalationError, ConsentDeniedError } from '../keys/types';
 /**
@@ -296,6 +296,38 @@ export interface ShardContext {
         result: unknown;
         scrollback: ScrollbackEntry[];
     }>;
+    /**
+     * Read-only snapshot of every action registered across every shard.
+     * Returns one descriptor per action id; the `active` flag indicates
+     * whether `runAction(id)` would dispatch right now (scope live, not
+     * disabled, has a run handler).
+     *
+     * Pass `{ activeOnly: true }` to filter to currently-dispatchable
+     * actions. AI-class shards typically want this filter.
+     *
+     * No permission gate — actions are already enumerable through the
+     * keyboard / palette / context-menu surfaces.
+     */
+    listActions(opts?: {
+        activeOnly?: boolean;
+    }): ActionDescriptor[];
+    /**
+     * Programmatically dispatch a registered action by id. Synthesizes the
+     * same `ActionDispatchContext` the keyboard/palette/context-menu paths
+     * use, with `invokedVia: 'programmatic'` and `appId / viewId / selection`
+     * sourced from current live state. Resolves after the action's `run`
+     * settles. Rejects on:
+     *   - unknown action id,
+     *   - action exists but is inactive (out-of-scope, disabled, submenu
+     *     parent without `run`),
+     *   - any error thrown by the action's `run`.
+     *
+     * `opts.signal` is stored on the dispatch context for v1 parity with
+     * `runVerb`; today's actions don't read it.
+     */
+    runAction(id: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
 }
 /**
  * A shard module. Shards are the fundamental unit of contribution in SH3.

package/dist/shell-shard/CommandLine.svelte

@@ -0,0 +1,143 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+
+  /**
+   * Single-line command entry widget. The chrome (focus ring, prefix slot,
+   * monospace font, anti-credential-fill attrs) is owned here; consumers
+   * supply the keybinding semantics via `onkeydown`.
+   *
+   * Two behaviors are baked in so every consumer gets them for free:
+   *   - Selection-aware Ctrl+C: when the input has a non-empty selection,
+   *     the keystroke is NOT forwarded to onkeydown — the browser does its
+   *     native copy. This avoids the consumer mapping Ctrl+C to "clear
+   *     draft" or "send SIGINT" eating a copy operation.
+   *   - data-sh3-passthrough-modifiers on the row: the dispatcher's
+   *     "block shortcuts in inputs" rule lets Ctrl/Alt/Meta-bearing
+   *     shortcuts through this widget, so global bindings like Ctrl+K
+   *     fire while the user is typing.
+   */
+  interface Props {
+    value: string;
+    prefix?: Snippet;
+    disabled?: boolean;
+    name?: string;
+    onkeydown?: (e: KeyboardEvent) => void;
+  }
+  let {
+    value = $bindable(''),
+    prefix,
+    disabled = false,
+    name,
+    onkeydown,
+  }: Props = $props();
+
+  let input: HTMLInputElement | null = $state(null);
+
+  function hasSelection(el: HTMLInputElement): boolean {
+    return el.selectionStart !== null
+      && el.selectionEnd !== null
+      && el.selectionStart !== el.selectionEnd;
+  }
+
+  function handleKeyDown(e: KeyboardEvent): void {
+    if ((e.ctrlKey || e.metaKey) && !e.altKey && e.key === 'c'
+        && input && hasSelection(input)) {
+      return;
+    }
+    onkeydown?.(e);
+  }
+
+  $effect(() => {
+    if (!disabled && input) input.focus();
+  });
+</script>
+
+<div
+  class="sh3-cmdline"
+  class:sh3-cmdline--disabled={disabled}
+  data-sh3-passthrough-modifiers
+>
+  {#if prefix}<span class="sh3-cmdline__prefix">{@render prefix()}</span>{/if}
+  <!--
+    Two hidden inputs sit before the real one so Firefox doesn't try to
+    autofill saved credentials into a single visible text field. Source:
+    https://stackoverflow.com/a/29852908 (CC BY-SA 3.0, Bob The Janitor).
+  -->
+  <input type="text" class="sh3-cmdline__decoy" tabindex="-1" aria-hidden="true" />
+  <input type="password" class="sh3-cmdline__decoy" tabindex="-1" aria-hidden="true" />
+  <input
+    bind:this={input}
+    bind:value
+    type="search"
+    {name}
+    {disabled}
+    onkeydown={handleKeyDown}
+    spellcheck="false"
+    autocomplete="off"
+    autocapitalize="off"
+    aria-autocomplete="none"
+    data-1p-ignore
+    data-lpignore="true"
+    class="sh3-cmdline__input"
+  />
+</div>
+
+<style>
+  .sh3-cmdline {
+    display: flex;
+    align-items: baseline;
+    gap: 6px;
+    padding: 4px 8px;
+    border: 1px solid transparent;
+    border-radius: var(--shell-radius);
+    font-family: var(--shell-font-mono, monospace);
+    font-size: var(--shell-font-size, 13px);
+    line-height: 1.4;
+    transition: border-color var(--shell-motion-fast) var(--shell-ease-standard),
+                box-shadow var(--shell-motion-fast) var(--shell-ease-standard);
+  }
+  .sh3-cmdline:focus-within {
+    border-color: var(--shell-input-border-focus);
+    box-shadow: var(--shell-focus-ring);
+  }
+  .sh3-cmdline__prefix {
+    flex-shrink: 0;
+    font: inherit;
+    line-height: inherit;
+    margin: 0;
+  }
+  .sh3-cmdline__input {
+    flex: 1 1 auto;
+    padding: 0;
+    margin: 0;
+    background: transparent;
+    border: 0;
+    outline: 0;
+    color: inherit;
+    font: inherit;
+    line-height: inherit;
+    -webkit-appearance: none;
+    appearance: none;
+  }
+  .sh3-cmdline__input::-webkit-search-cancel-button,
+  .sh3-cmdline__input::-webkit-search-decoration,
+  .sh3-cmdline__input::-webkit-search-results-button,
+  .sh3-cmdline__input::-webkit-search-results-decoration {
+    display: none;
+  }
+  /* The .sh3-cmdline row owns the focus ring; suppress base.css's global
+     input:focus-visible box-shadow so the rings don't double up. */
+  .sh3-cmdline__input:focus,
+  .sh3-cmdline__input:focus-visible {
+    outline: none;
+    box-shadow: none;
+    border: none;
+  }
+  .sh3-cmdline__decoy {
+    display: none;
+  }
+  .sh3-cmdline--disabled .sh3-cmdline__input {
+    opacity: 0.5;
+    cursor: default;
+  }
+</style>

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

@@ -0,0 +1,26 @@
+import type { Snippet } from 'svelte';
+/**
+ * Single-line command entry widget. The chrome (focus ring, prefix slot,
+ * monospace font, anti-credential-fill attrs) is owned here; consumers
+ * supply the keybinding semantics via `onkeydown`.
+ *
+ * Two behaviors are baked in so every consumer gets them for free:
+ *   - Selection-aware Ctrl+C: when the input has a non-empty selection,
+ *     the keystroke is NOT forwarded to onkeydown — the browser does its
+ *     native copy. This avoids the consumer mapping Ctrl+C to "clear
+ *     draft" or "send SIGINT" eating a copy operation.
+ *   - data-sh3-passthrough-modifiers on the row: the dispatcher's
+ *     "block shortcuts in inputs" rule lets Ctrl/Alt/Meta-bearing
+ *     shortcuts through this widget, so global bindings like Ctrl+K
+ *     fire while the user is typing.
+ */
+interface Props {
+    value: string;
+    prefix?: Snippet;
+    disabled?: boolean;
+    name?: string;
+    onkeydown?: (e: KeyboardEvent) => void;
+}
+declare const CommandLine: import("svelte").Component<Props, {}, "value">;
+type CommandLine = ReturnType<typeof CommandLine>;
+export default CommandLine;

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

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

package/dist/shell-shard/CommandLine.svelte.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, fireEvent } from '@testing-library/svelte';
+import CommandLine from './CommandLine.svelte';
+function realInput(container) {
+    // The widget renders two FF-credential decoy inputs ahead of the real one.
+    return container.querySelector('input.sh3-cmdline__input');
+}
+describe('CommandLine selection-aware Ctrl+C', () => {
+    it('does NOT forward Ctrl+C to onkeydown when input has a non-empty selection', async () => {
+        const onkeydown = vi.fn();
+        const { container } = render(CommandLine, { props: { value: 'hello world', onkeydown } });
+        const inp = realInput(container);
+        inp.focus();
+        inp.setSelectionRange(0, 5); // select "hello"
+        await fireEvent.keyDown(inp, { key: 'c', ctrlKey: true });
+        expect(onkeydown).not.toHaveBeenCalled();
+    });
+    it('forwards Ctrl+C to onkeydown when there is no selection', async () => {
+        const onkeydown = vi.fn();
+        const { container } = render(CommandLine, { props: { value: 'hello', onkeydown } });
+        const inp = realInput(container);
+        inp.focus();
+        inp.setSelectionRange(3, 3); // caret only, no selection
+        await fireEvent.keyDown(inp, { key: 'c', ctrlKey: true });
+        expect(onkeydown).toHaveBeenCalledTimes(1);
+    });
+    it('forwards non-Ctrl+C keys regardless of selection', async () => {
+        const onkeydown = vi.fn();
+        const { container } = render(CommandLine, { props: { value: 'hello', onkeydown } });
+        const inp = realInput(container);
+        inp.focus();
+        inp.setSelectionRange(0, 5);
+        await fireEvent.keyDown(inp, { key: 'k', ctrlKey: true });
+        expect(onkeydown).toHaveBeenCalledTimes(1);
+    });
+});
+describe('CommandLine modifier passthrough attribute', () => {
+    it('stamps data-sh3-passthrough-modifiers so the dispatcher lets modifier shortcuts through', () => {
+        const { container } = render(CommandLine, { props: { value: '' } });
+        const row = container.querySelector('.sh3-cmdline');
+        expect(row.hasAttribute('data-sh3-passthrough-modifiers')).toBe(true);
+    });
+});