sh3-core 0.10.4 → 0.11.2

package/dist/shards/types.js

@@ -12,9 +12,10 @@
  *   - A ViewFactory knows how to mount a view into a raw HTMLElement and
  *     return a handle the framework uses to unmount / notify of resizes.
  *
- * Deferred to later phases: bus scoping, command/toolbar/menu/hotkey
- * registration, modal provider contributions, background services, lazy
- * activation events. They'll slot into `ShardContext` as new `register*`
- * methods without disturbing the phase-4 shape.
+ * Action contributions (commands, hotkeys, context menus) shipped in v0.11.0
+ * via `ctx.actions` (see `../actions/types.ts`). Still deferred to later
+ * phases: bus scoping, toolbar registration, modal provider contributions,
+ * background services, lazy activation events. They'll slot into `ShardContext`
+ * as new `register*` methods without disturbing the phase-4 shape.
  */
 export { PERMISSION_KEYS_MINT, ScopeEscalationError, ConsentDeniedError } from '../keys/types';

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

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

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

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { resetFramework } from '../__test__/reset';
+import { makeApp, makeAppManifest, makeTabEntry, makeTabsNode, makeTree } from '../__test__/fixtures';
+import { registerApp } from '../apps/registry.svelte';
+import { launchApp } from '../apps/lifecycle';
+import { floatManager, bindFloatStore } from '../overlays/float';
+import { layoutStore } from '../layout/store.svelte';
+import { makeShellApiForTest } from './shellShard.svelte';
+describe('ShellApi.locateSlot', () => {
+    beforeEach(resetFramework);
+    it('returns docked for a slot in the docked tree', async () => {
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'test-app-docked' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeTabsNode([makeTabEntry({ slotId: 'dock-x' })])),
+                },
+            ],
+        }));
+        await launchApp('test-app-docked');
+        const shell = makeShellApiForTest();
+        expect(shell.locateSlot('dock-x')).toEqual({ kind: 'docked' });
+    });
+    it('returns float for a slot in a float', async () => {
+        var _a;
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'test-app-float' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeTabsNode([makeTabEntry({ slotId: 'stay-docked' })])),
+                },
+            ],
+        }));
+        await launchApp('test-app-float');
+        // Shell.svelte normally binds the float manager to the active tree's
+        // floats array during boot. In tests we bind it manually so
+        // floatManager.open() writes into the tree that locateSlot walks.
+        bindFloatStore(layoutStore.floats, () => ({ w: 1024, h: 768 }));
+        const floatId = floatManager.open('v', { title: 'Float X' });
+        const openedFloat = layoutStore.floats.find((f) => f.id === floatId);
+        expect(openedFloat).toBeDefined();
+        const tabs = openedFloat.content.type === 'tabs' ? openedFloat.content : null;
+        const floatSlotId = (_a = tabs === null || tabs === void 0 ? void 0 : tabs.tabs[0]) === null || _a === void 0 ? void 0 : _a.slotId;
+        expect(floatSlotId).toBeTruthy();
+        const shell = makeShellApiForTest();
+        expect(shell.locateSlot(floatSlotId)).toEqual({ kind: 'float', floatId });
+    });
+    it('returns null for an absent slot', async () => {
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'test-app-absent' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeTabsNode([makeTabEntry({ slotId: 'existing' })])),
+                },
+            ],
+        }));
+        await launchApp('test-app-absent');
+        const shell = makeShellApiForTest();
+        expect(shell.locateSlot('nonexistent-slot')).toBeNull();
+    });
+});
+import { popoutView, inspectActiveLayout } from '../layout/inspection';
+describe('ShellApi.locateSlot — round-trip', () => {
+    beforeEach(resetFramework);
+    it('tracks the docked → popout → float transition', async () => {
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'test-app-rt' }),
+            initialLayout: [
+                {
+                    name: 'default',
+                    tree: makeTree(makeTabsNode([
+                        makeTabEntry({ slotId: 'rt-1', viewId: 'rt:one' }),
+                        makeTabEntry({ slotId: 'rt-anchor', viewId: 'rt:anchor' }),
+                    ])),
+                },
+            ],
+        }));
+        await launchApp('test-app-rt');
+        // Shell.svelte would bind this at boot; in tests we do it ourselves.
+        bindFloatStore(layoutStore.floats, () => ({ w: 1024, h: 768 }));
+        const shell = makeShellApiForTest();
+        // Starts docked.
+        expect(shell.locateSlot('rt-1')).toEqual({ kind: 'docked' });
+        // Popout removes the original docked tab and opens a float with a
+        // fresh slotId wrapped around the same view.
+        const floatId = popoutView('rt-1');
+        expect(floatId).not.toBeNull();
+        expect(shell.locateSlot('rt-1')).toBeNull();
+        // The float-era slotId resolves to the new float.
+        const { root } = inspectActiveLayout();
+        const fl = root.floats.find((f) => f.id === floatId);
+        const floatSlot = fl.content.type === 'tabs' ? fl.content.tabs[0].slotId : '';
+        expect(floatSlot).toBeTruthy();
+        expect(shell.locateSlot(floatSlot)).toEqual({ kind: 'float', floatId });
+        // Anchor tab is untouched and still docked.
+        expect(shell.locateSlot('rt-anchor')).toEqual({ kind: 'docked' });
+    });
+});

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

@@ -1,2 +1,9 @@
 import type { Shard } from '../api';
+import type { ShellApi } from './registry';
+/**
+ * Test-only ShellApi constructor. Bypasses the admin gate and uses a
+ * stub ShardContext. Only methods that do not consult `ctx` are
+ * guaranteed to work — `locateSlot`, `listFloats`, `listApps`, etc.
+ */
+export declare function makeShellApiForTest(): ShellApi;
 export declare const shellShard: Shard;

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

@@ -19,7 +19,7 @@ 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, popoutView, dockFloat, dockIntoActiveLayout } from '../layout/inspection';
+import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIntoActiveLayout, locateSlot as locateSlotInActiveLayout } from '../layout/inspection';
 import { floatManager } from '../overlays/float';
 import { listStandaloneViews } from '../shards/activate.svelte';
 import { getUser, isAdmin } from '../auth/index';
@@ -121,6 +121,15 @@ function makeShellApi(_ctx) {
                 return { ok: false, error: err instanceof Error ? err.message : String(err) };
             }
         },
+        // → layout/inspection: locateSlot(slotId) returns TreeRootRef | null
+        locateSlot(slotId) {
+            try {
+                return locateSlotInActiveLayout(slotId);
+            }
+            catch (_a) {
+                return null;
+            }
+        },
         // → overlays/float: floatManager.list() returns FloatEntry[]
         listFloats() {
             return floatManager.list().map((f) => {
@@ -156,6 +165,14 @@ function makeShellApi(_ctx) {
         },
     };
 }
+/**
+ * Test-only ShellApi constructor. Bypasses the admin gate and uses a
+ * stub ShardContext. Only methods that do not consult `ctx` are
+ * guaranteed to work — `locateSlot`, `listFloats`, `listApps`, etc.
+ */
+export function makeShellApiForTest() {
+    return makeShellApi({});
+}
 export const shellShard = {
     manifest,
     activate(ctx) {
@@ -165,6 +182,22 @@ export const shellShard = {
         }
         registerV1Verbs(ctx);
         const shell = makeShellApi(ctx);
+        // The AZERTY `²` key (top-left on FR keyboards, below Escape) opens the
+        // terminal view — focusing it if already mounted, floating it otherwise.
+        // Migrated from Shell.svelte's inline keydown handler as proof-of-concept
+        // for the Actions framework (Task 23 / DF1). Registered here because this
+        // shard owns the terminal view and is already admin-gated.
+        ctx.actions.register({
+            id: 'shell.terminal.toggle',
+            label: 'Open Terminal',
+            scope: ['home', 'app'],
+            defaultShortcut: '²',
+            allowInInputs: false,
+            run() {
+                if (!focusView('shell:terminal'))
+                    floatManager.open('shell:terminal', { title: 'Shell' });
+            },
+        });
         const factory = {
             mount(container, _context) {
                 var _a;

package/dist/shellRuntime.svelte.d.ts

@@ -6,6 +6,7 @@ import { type ToastManager } from './overlays/toast';
 import { type FloatManager } from './overlays/float';
 import { type PresetManager } from './overlays/presets';
 import type { ConflictsApi } from './conflicts/api';
+import { type OpenContextMenuOpts, type OpenPaletteOpts } from './actions/listeners';
 /**
  * The process-wide shell singleton exposed to shards and the shell's own
  * internal code. Provides state zone creation and overlay managers.
@@ -31,6 +32,24 @@ export interface Shell {
     presets: PresetManager;
     /** Conflict manager view. Shell-owned modal for conflict arbitration. */
     conflicts: ConflictsApi;
+    /** Actions facade — rebind keys, query bindings, open menus/palette. */
+    actions: ShellActionsApi;
+}
+/**
+ * API for managing action bindings and triggering menus/palette
+ * programmatically (e.g. from a future settings UI shard).
+ */
+export interface ShellActionsApi {
+    /** Persist a custom shortcut for an action and refresh live state if the app is active. */
+    rebind(appId: string, actionId: string, shortcut: string | null): Promise<void>;
+    /** Remove a custom shortcut override and refresh live state if the app is active. */
+    resetBinding(appId: string, actionId: string): Promise<void>;
+    /** Return all non-null user bindings for an app as a plain string map. */
+    bindingsFor(appId: string): Promise<Record<string, string>>;
+    /** Open the context menu at the given screen coordinates. */
+    openContextMenu(opts: OpenContextMenuOpts): void;
+    /** Open the command palette, optionally pre-filled. */
+    openPalette(opts?: OpenPaletteOpts): void;
 }
 /** The process-wide shell instance. Framework-internal code uses this directly; shards receive a scoped view via `ShardContext`. */
 export declare const shell: Shell;

package/dist/shellRuntime.svelte.js

@@ -21,6 +21,35 @@ import { toastManager } from './overlays/toast';
 import { floatManager } from './overlays/float';
 import { presetManager } from './overlays/presets';
 import { conflictsApi } from './conflicts/shell-api';
+import { loadUserBindings, saveUserBinding } from './actions/bindings-store';
+import { openContextMenu as listenersOpenContextMenu, openPalette as listenersOpenPalette, } from './actions/listeners';
+import { setUserBindings, getLiveDispatcherState } from './actions/state.svelte';
+const shellActions = {
+    async rebind(appId, actionId, shortcut) {
+        await saveUserBinding(appId, actionId, shortcut);
+        const current = getLiveDispatcherState();
+        if (current.activeAppId === appId) {
+            setUserBindings(await loadUserBindings(appId));
+        }
+    },
+    async resetBinding(appId, actionId) {
+        await saveUserBinding(appId, actionId, undefined);
+        const current = getLiveDispatcherState();
+        if (current.activeAppId === appId) {
+            setUserBindings(await loadUserBindings(appId));
+        }
+    },
+    async bindingsFor(appId) {
+        const raw = await loadUserBindings(appId);
+        const out = {};
+        for (const [id, v] of Object.entries(raw))
+            if (v !== null)
+                out[id] = v;
+        return out;
+    },
+    openContextMenu: listenersOpenContextMenu,
+    openPalette: listenersOpenPalette,
+};
 /** The process-wide shell instance. Framework-internal code uses this directly; shards receive a scoped view via `ShardContext`. */
 export const shell = {
     state: createStateZones,
@@ -30,4 +59,5 @@ export const shell = {
     float: floatManager,
     presets: presetManager,
     conflicts: conflictsApi,
+    actions: shellActions,
 };

package/dist/tokens.css

@@ -42,6 +42,16 @@
   --shell-warning: #fbbf24;
   --shell-success: #34d399;
 
+  /* Foreground pairings — the contrasting text/icon color for each
+     semantic surface. Used instead of --shell-fg when the background
+     is a saturated semantic color rather than --shell-bg. Theme
+     overrides that change the surface hue should also update its
+     paired foreground. */
+  --shell-fg-on-accent:  #ffffff;
+  --shell-fg-on-error:   #1a1b1e;
+  --shell-fg-on-warning: #1a1b1e;
+  --shell-fg-on-success: #1a1b1e;
+
   /* Typography */
   --shell-font-ui:   system-ui, -apple-system, "Segoe UI", sans-serif;
   --shell-font-mono: ui-monospace, "Cascadia Code", "Consolas", monospace;
@@ -90,7 +100,7 @@ body {
   margin: 0;
   padding: 0;
   height: 100%;
-  overflow: hidden; /* SH3 is a shell, not a scrollable document */
+  overflow: hidden;
   background: var(--shell-grad-bg, var(--shell-bg));
   color: var(--shell-fg);
   font-family: var(--shell-font-ui);

package/dist/verbs/types.d.ts

@@ -1,6 +1,7 @@
 import type { Scrollback } from '../shell-shard/scrollback.svelte';
 import type { SessionClient } from '../shell-shard/session-client.svelte';
 import type { TenantFsClient } from '../shell-shard/tenant-fs-client';
+import type { TreeRootRef } from '../layout/types';
 export interface ShellApi {
     listApps(): Array<{
         id: string;
@@ -48,6 +49,14 @@ export interface ShellApi {
         viewId: string | null;
         label: string;
     }>;
+    /**
+     * Where is this slot currently mounted? Returns `{ kind: 'docked' }`
+     * when the slot is anywhere in the active docked tree, or
+     * `{ kind: 'float', floatId }` when it lives inside a float's subtree.
+     * Returns `null` when the slot is not present in the active layout
+     * (stale id, post-unmount, or held-but-not-active app tree).
+     */
+    locateSlot(slotId: string): TreeRootRef | null;
     listZones(shardId?: string): Array<{
         shardId: string;
         zones: string[];

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.10.4";
+export declare const VERSION = "0.11.2";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.10.4';
+export const VERSION = '0.11.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.10.4",
+  "version": "0.11.2",
   "type": "module",
   "files": [
     "dist"

package/dist/apps/terminal/manifest.d.ts

@@ -1,8 +0,0 @@
-/**
- * Terminal app manifest.
- *
- * Framework-shipped: registered in host.ts during bootstrap.
- * Requires the `shell` shard which provides the `shell:terminal` view.
- */
-import type { AppManifest } from '../../apps/types';
-export declare const manifest: AppManifest;

package/dist/apps/terminal/manifest.js

@@ -1,14 +0,0 @@
-/**
- * Terminal app manifest.
- *
- * Framework-shipped: registered in host.ts during bootstrap.
- * Requires the `shell` shard which provides the `shell:terminal` view.
- */
-import { VERSION } from '../../version';
-export const manifest = {
-    id: 'terminal',
-    label: 'Terminal',
-    version: VERSION,
-    requiredShards: ['shell'],
-    layoutVersion: 1,
-};

package/dist/apps/terminal/terminal-app.d.ts

@@ -1,7 +0,0 @@
-/**
- * Built-in Terminal app — mounts the `shell:terminal` view in a single slot.
- *
- * Framework-shipped: registered in host.ts during bootstrap.
- */
-import type { App } from '../../apps/types';
-export declare const terminalApp: App;

package/dist/apps/terminal/terminal-app.js

@@ -1,14 +0,0 @@
-/**
- * Built-in Terminal app — mounts the `shell:terminal` view in a single slot.
- *
- * Framework-shipped: registered in host.ts during bootstrap.
- */
-import { manifest } from './manifest';
-export const terminalApp = {
-    manifest,
-    initialLayout: {
-        type: 'slot',
-        slotId: 'terminal.main',
-        viewId: 'shell:terminal',
-    },
-};