sh3-core 0.11.4 → 0.11.7

package/dist/actions/paletteModel.test.js

@@ -47,3 +47,46 @@ describe('buildPaletteCandidates', () => {
         expect(out[0].scopeBadge).toBe('view:editor');
     });
 });
+describe('buildPaletteCandidates — submenu and filter', () => {
+    it('filter.submenuOf: only returns children of the given parent', () => {
+        const entries = [
+            mkEntry({ id: 'p', scope: 'home', label: 'P', submenu: true }),
+            mkEntry({ id: 'p.a', scope: 'home', label: 'A', submenuOf: 'p' }),
+            mkEntry({ id: 'p.b', scope: 'home', label: 'B', submenuOf: 'p' }),
+            mkEntry({ id: 'q.x', scope: 'home', label: 'X', submenuOf: 'q' }),
+            mkEntry({ id: 'r', scope: 'home', label: 'R' }),
+        ];
+        const out = buildPaletteCandidates(entries, mkState(), { filter: { submenuOf: 'p' } });
+        expect(out.map((c) => c.id)).toEqual(['p.a', 'p.b']);
+    });
+    it('returns all active candidates by default (children included; scorer hides them on empty query)', () => {
+        const entries = [
+            mkEntry({ id: 'p', scope: 'home', label: 'P', submenu: true }),
+            mkEntry({ id: 'p.a', scope: 'home', label: 'A', submenuOf: 'p' }),
+        ];
+        const out = buildPaletteCandidates(entries, mkState());
+        expect(out.map((c) => c.id).sort()).toEqual(['p', 'p.a']);
+    });
+    it('hides disabled actions', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'home', label: 'A', disabled: true }),
+            mkEntry({ id: 'b', scope: 'home', label: 'B', disabled: () => true }),
+            mkEntry({ id: 'c', scope: 'home', label: 'C' }),
+        ];
+        const out = buildPaletteCandidates(entries, mkState(), {});
+        expect(out.map((c) => c.id)).toEqual(['c']);
+    });
+    it('annotates submenu and submenuOf on candidates', () => {
+        const entries = [
+            mkEntry({ id: 'p', scope: 'home', label: 'P', submenu: true }),
+            mkEntry({ id: 'p.a', scope: 'home', label: 'A', submenuOf: 'p' }),
+        ];
+        const out = buildPaletteCandidates(entries, mkState());
+        const parent = out.find((c) => c.id === 'p');
+        const child = out.find((c) => c.id === 'p.a');
+        expect(parent.submenu).toBe(true);
+        expect(parent.submenuOf).toBeUndefined();
+        expect(child.submenu).toBe(false);
+        expect(child.submenuOf).toBe('p');
+    });
+});

package/dist/actions/registry.js

@@ -9,6 +9,11 @@ import { register as contributionsRegister, list as contributionsList, onChange
 export const ACTIONS_POINT_ID = 'sh3.actions';
 const liveIds = new Set();
 export function registerAction(action, ownerShardId) {
+    if (typeof action.run !== 'function' && action.submenu !== true) {
+        console.warn(`[sh3] Action "${action.id}" registered by "${ownerShardId}" has no \`run\` ` +
+            `and is not a submenu parent (\`submenu: true\`). Registration ignored.`);
+        return () => { };
+    }
     if (liveIds.has(action.id)) {
         console.warn(`[sh3] Duplicate action id "${action.id}" registered by "${ownerShardId}". ` +
             `First registration wins; second registration still stored but shortcut conflicts may occur.`);

package/dist/actions/registry.test.js

@@ -46,4 +46,16 @@ describe('actions registry', () => {
         expect(warn).toHaveBeenCalled();
         warn.mockRestore();
     });
+    it('warns and rejects an action with neither run nor submenu', () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const dispose = registerAction({ id: 'no-op', label: 'No-Op', scope: 'home' }, 'shard.a');
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining('"no-op"'));
+        expect(listActions()).toHaveLength(0);
+        dispose();
+        warn.mockRestore();
+    });
+    it('accepts a submenu parent without run', () => {
+        registerAction({ id: 'p', label: 'Parent', scope: 'home', submenu: true }, 'shard.a');
+        expect(listActions()).toHaveLength(1);
+    });
 });

package/dist/actions/types.d.ts

@@ -8,11 +8,55 @@ export interface Action {
     scope: ActionScope;
     contextItem?: boolean;
     paletteItem?: boolean;
+    /**
+     * Optional menu container id. When set and the active app's declared
+     * (or canonical fallback) menu list contains this id, the action
+     * appears in that container's dropdown. Orphaned values render
+     * nowhere in the menu bar; the action remains reachable via
+     * palette/hotkey/context menu.
+     */
+    menuItem?: string;
     defaultShortcut?: string;
     icon?: string;
+    /**
+     * Optional grouping key. Items inside the same surface (menu bar
+     * dropdown, context menu, submenu popup) with distinct `group`
+     * values are separated by a divider line in `ActionPanel`. This is
+     * the only separator mechanism — there is no explicit separator
+     * primitive. Items without a `group` form a single default group.
+     */
     group?: string;
     allowInInputs?: boolean;
-    run(ctx: ActionDispatchContext): void | Promise<void>;
+    /**
+     * Toggle-state indicator. Truthy renders a leading ✓ in MenuBar /
+     * ContextMenu rows. Function form is re-evaluated on each derive
+     * (no re-registration on flip). Ignored in CommandPalette.
+     */
+    checked?: boolean | (() => boolean);
+    /**
+     * Visible-but-not-dispatchable. Greyed in MenuBar/ContextMenu,
+     * skipped by keyboard nav, click is a no-op, shortcut dispatch is
+     * blocked. Hidden from CommandPalette in v1 (a future "show
+     * disabled" toggle is acknowledged in the spec but out of scope).
+     */
+    disabled?: boolean | (() => boolean);
+    /**
+     * Marks this action as a submenu parent. `run` becomes optional —
+     * when omitted, the framework provides default drill-down behavior:
+     * MenuBar/ContextMenu render the row as actionless+expanding;
+     * CommandPalette opens a sub-palette filtered to children
+     * (`submenuOf === this.id`).
+     */
+    submenu?: true;
+    /**
+     * Marks this action as a child of `submenuOf`'s submenu. Children
+     * inherit the parent's surface placement — they do NOT repeat
+     * `menuItem`, `contextItem`, or `paletteItem`. Children are excluded
+     * from their parent's container's flat list and only appear in the
+     * parent's submenu popup or via direct match in the palette.
+     */
+    submenuOf?: string;
+    run?(ctx: ActionDispatchContext): void | Promise<void>;
 }
 export interface Selection {
     type: string;
@@ -47,6 +91,9 @@ export interface ActionsApi {
     }): void;
     openPalette(opts?: {
         prefill?: string;
+        filter?: {
+            submenuOf?: string;
+        };
     }): void;
 }
 export interface ResolvedAction {

package/dist/actions/types.test.d.ts

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

package/dist/actions/types.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expectTypeOf } from 'vitest';
+describe('Action type', () => {
+    it('accepts an action without run when submenu: true', () => {
+        const a = {
+            id: 'p',
+            label: 'Parent',
+            scope: 'home',
+            submenu: true,
+        };
+        expectTypeOf(a).toMatchTypeOf();
+    });
+    it('accepts checked / disabled as boolean or function', () => {
+        const flat = {
+            id: 'a', label: 'A', scope: 'home',
+            run: () => { }, checked: true, disabled: false,
+        };
+        const reactive = {
+            id: 'b', label: 'B', scope: 'home',
+            run: () => { }, checked: () => true, disabled: () => false,
+        };
+        expectTypeOf(flat).toMatchTypeOf();
+        expectTypeOf(reactive).toMatchTypeOf();
+    });
+    it('accepts submenuOf as a string id', () => {
+        const c = {
+            id: 'c', label: 'C', scope: 'home',
+            submenuOf: 'p', run: () => { },
+        };
+        expectTypeOf(c).toMatchTypeOf();
+    });
+});

package/dist/apps/lifecycle.js

@@ -14,7 +14,7 @@
 import { createStateZones } from '../state/zones.svelte';
 import { activateShard, deactivateShard, getShardContext, registeredShards, } from '../shards/activate.svelte';
 import { attachApp, acquireAppSlotHolds, detachApp, switchToApp, switchToHome, } from '../layout/store.svelte';
-import { activeApp, getRegisteredApp, registeredApps } from './registry.svelte';
+import { activeApp, breadcrumbApp, getRegisteredApp, registeredApps } from './registry.svelte';
 import { createZoneManager } from '../state/manage';
 import { PERMISSION_STATE_MANAGE } from '../state/types';
 import { setActiveApp, setUserBindings } from '../actions/state.svelte';
@@ -96,6 +96,7 @@ export async function launchApp(id) {
         switchToApp();
         void ((_c = app.onAppReady) === null || _c === void 0 ? void 0 : _c.call(app, getOrCreateAppContext(id)));
         writeLastApp(id);
+        breadcrumbApp.id = id;
         setActiveApp(id, new Set((_d = app.manifest.requiredShards) !== null && _d !== void 0 ? _d : []));
         void loadUserBindings(id).then(setUserBindings);
         return;
@@ -135,6 +136,7 @@ export async function launchApp(id) {
     switchToApp();
     void ((_g = app.onAppReady) === null || _g === void 0 ? void 0 : _g.call(app, getOrCreateAppContext(id)));
     writeLastApp(id);
+    breadcrumbApp.id = id;
 }
 // ---------- unload --------------------------------------------------------
 /**
@@ -226,6 +228,11 @@ export async function returnToHome() {
             return false;
     }
     switchToHome();
+    // Mirror unregisterApp: clear the dispatcher's active-app pointer so
+    // 'app'-scope actions become inactive on home. Without this, any action
+    // registered with scope: ['app'] keeps appearing in the palette while
+    // the user is on home.
+    setActiveApp(null, new Set());
     writeLastApp(null);
     return true;
 }

package/dist/apps/lifecycle.test.js

@@ -5,7 +5,7 @@ import { launchApp, returnToHome, unregisterApp } from './lifecycle';
 import { registerApp } from './registry.svelte';
 import { registerShard } from '../shards/activate.svelte';
 import { presetManager } from '../overlays/presets';
-import { layoutStore } from '../layout/store.svelte';
+import { layoutStore, resetActivePresetToDefault } from '../layout/store.svelte';
 import LayoutRenderer from '../layout/LayoutRenderer.svelte';
 import { renderWithShell } from '../__test__/render';
 import { registerView } from '../shards/registry';
@@ -307,3 +307,213 @@ describe('installPackage evict-before-register (simulated via registerLoadedBund
         expect((_b = registeredShards.get('S')) === null || _b === void 0 ? void 0 : _b.manifest.version).toBe('1.0.1');
     });
 });
+// ---------------------------------------------------------------------------
+// Scenario C.1 — resetActivePresetToDefault rebuilds the active preset
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.1 happy path', () => {
+    beforeEach(resetFramework);
+    it('replaces the active preset tree with a fresh copy of initialLayout', async () => {
+        var _a;
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-1' }),
+            initialLayout: [
+                {
+                    name: 'main',
+                    tree: makeTree(makeTabsNode([
+                        makeTabEntry({ slotId: 'a', label: 'A' }),
+                        makeTabEntry({ slotId: 'b', label: 'B' }),
+                    ])),
+                },
+            ],
+        }));
+        await launchApp('reset-1');
+        // Mutate the live tree: change activeTab and add a float.
+        const root = layoutStore.root;
+        expect(root === null || root === void 0 ? void 0 : root.type).toBe('tabs');
+        if ((root === null || root === void 0 ? void 0 : root.type) === 'tabs')
+            root.activeTab = 1;
+        layoutStore.tree.floats.push({
+            id: 'float-test',
+            content: makeSlotNode('floated'),
+            position: { x: 10, y: 10 },
+            size: { w: 100, h: 100 },
+        });
+        expect(layoutStore.tree.floats.length).toBe(1);
+        resetActivePresetToDefault();
+        const resetRoot = layoutStore.root;
+        expect(resetRoot === null || resetRoot === void 0 ? void 0 : resetRoot.type).toBe('tabs');
+        if ((resetRoot === null || resetRoot === void 0 ? void 0 : resetRoot.type) === 'tabs') {
+            expect((_a = resetRoot.activeTab) !== null && _a !== void 0 ? _a : 0).toBe(0);
+            expect(resetRoot.tabs.map((t) => t.slotId)).toEqual(['a', 'b']);
+        }
+        expect(layoutStore.tree.floats.length).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.2 — reset falls back when active preset name no longer exists
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.2 missing-preset fallback', () => {
+    beforeEach(resetFramework);
+    it('falls back to canonical[0] and updates activePreset when the stored name is gone', async () => {
+        // Launch with two presets, switch to the second, then simulate the app
+        // dropping that preset by re-registering it with a different layout.
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-2' }),
+            initialLayout: [
+                { name: 'first', tree: makeTree(makeSlotNode('x')) },
+                { name: 'second', tree: makeTree(makeSlotNode('y')) },
+            ],
+        }));
+        await launchApp('reset-2');
+        presetManager.switch('second');
+        expect(presetManager.active()).toBe('second');
+        // Replace the registry entry with a version that no longer declares
+        // 'second'. We mutate registeredApps directly because the public
+        // `unregisterApp` would also detach. This mimics the in-process
+        // version-update scenario for the reset code path.
+        const { registeredApps } = await import('./registry.svelte');
+        const existing = registeredApps.get('reset-2');
+        registeredApps.set('reset-2', Object.assign(Object.assign({}, existing), { initialLayout: [
+                { name: 'first', tree: makeTree(makeSlotNode('x')) },
+                // 'second' removed
+            ] }));
+        resetActivePresetToDefault();
+        expect(presetManager.active()).toBe('first');
+        // The previously-active 'second' preset is still in the blob (we
+        // don't garbage-collect dropped presets); only its name was vacated.
+        expect(layoutStore.root).toMatchObject({ type: 'slot', slotId: 'x' });
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.3 — reset throws when no app is attached
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.3 no app attached', () => {
+    beforeEach(resetFramework);
+    it('throws a useful error when called with no attached app', () => {
+        expect(() => resetActivePresetToDefault()).toThrow(/no app attached/);
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.4 — reset re-scopes slot-host refcount holds
+// ---------------------------------------------------------------------------
+describe('resetActivePresetToDefault — scenario C.4 slot-host hold accounting', () => {
+    beforeEach(resetFramework);
+    it('updates appEntry.heldSlotIds to match the rebuilt tree', async () => {
+        var _a, _b;
+        const { __inspectAppEntryHeldSlotIdsForTest } = await import('../layout/store.svelte');
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-3' }),
+            initialLayout: [
+                {
+                    name: 'main',
+                    tree: makeTree(makeTabsNode([
+                        makeTabEntry({ slotId: 't-a', label: 'A' }),
+                        makeTabEntry({ slotId: 't-b', label: 'B' }),
+                    ])),
+                },
+            ],
+        }));
+        await launchApp('reset-3');
+        expect((_a = __inspectAppEntryHeldSlotIdsForTest()) === null || _a === void 0 ? void 0 : _a.slice().sort()).toEqual(['t-a', 't-b']);
+        // Mutate the live tree by replacing the docked node with a different
+        // single slot. After reset, the held set must return to the default
+        // pair, which proves the old single hold was released and the
+        // canonical pair was re-acquired.
+        layoutStore.tree.docked = makeSlotNode('mutated');
+        resetActivePresetToDefault();
+        expect((_b = __inspectAppEntryHeldSlotIdsForTest()) === null || _b === void 0 ? void 0 : _b.slice().sort()).toEqual(['t-a', 't-b']);
+    });
+});
+// ---------------------------------------------------------------------------
+// Scenario C.5 — sh3.app.reset-layout is registered with the right shape
+// ---------------------------------------------------------------------------
+describe('sh3coreShard — sh3.app.reset-layout registration', () => {
+    beforeEach(resetFramework);
+    it('exposes a "Reset Current Layout" action scoped to app, palette-only', async () => {
+        // Register and activate the sh3core pseudo-shard the same way bootstrap()
+        // would — tests don't run bootstrap, so the shard's actions wouldn't
+        // otherwise be present.
+        const { sh3coreShard } = await import('../sh3core-shard/sh3coreShard.svelte');
+        const { activateShard } = await import('../shards/activate.svelte');
+        const { addAutostartShard } = await import('../actions/state.svelte');
+        registerShard(sh3coreShard);
+        // Mirror what bootstrap() does: mark the framework shard as autostart so
+        // its 'app'-scope actions are treated as ambient inside any app.
+        addAutostartShard(sh3coreShard.manifest.id);
+        await activateShard(sh3coreShard.manifest.id);
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-action-1' }),
+            initialLayout: [{ name: 'main', tree: makeTree(makeSlotNode('x')) }],
+        }));
+        await launchApp('reset-action-1');
+        const { shell } = await import('../shellRuntime.svelte');
+        const actions = shell.actions.listActive();
+        const reset = actions.find((a) => a.id === 'sh3.app.reset-layout');
+        expect(reset).toBeDefined();
+        expect(reset === null || reset === void 0 ? void 0 : reset.label).toBe('Reset Current Layout');
+        expect(reset === null || reset === void 0 ? void 0 : reset.paletteItem).toBe(true);
+        expect(reset === null || reset === void 0 ? void 0 : reset.contextItem).toBe(false);
+        expect(reset === null || reset === void 0 ? void 0 : reset.effectiveShortcut).toBeNull();
+    });
+    it('hides "app"-scope actions after returnToHome', async () => {
+        const { sh3coreShard } = await import('../sh3core-shard/sh3coreShard.svelte');
+        const { activateShard } = await import('../shards/activate.svelte');
+        const { addAutostartShard } = await import('../actions/state.svelte');
+        registerShard(sh3coreShard);
+        addAutostartShard(sh3coreShard.manifest.id);
+        await activateShard(sh3coreShard.manifest.id);
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'reset-action-2' }),
+            initialLayout: [{ name: 'main', tree: makeTree(makeSlotNode('x')) }],
+        }));
+        await launchApp('reset-action-2');
+        const { shell } = await import('../shellRuntime.svelte');
+        expect(shell.actions.listActive().some((a) => a.id === 'sh3.app.reset-layout')).toBe(true);
+        await returnToHome();
+        expect(shell.actions.listActive().some((a) => a.id === 'sh3.app.reset-layout')).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// breadcrumbAppId — lingers across returnToHome (distinct from lastAppState)
+// ---------------------------------------------------------------------------
+describe('breadcrumbAppId', () => {
+    beforeEach(resetFramework);
+    it('starts null when no app has launched this session', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        expect(getBreadcrumbAppId()).toBeNull();
+    });
+    it('is set to the launched app id', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        registerShard(makeShard({ manifest: makeShardManifest({ id: 'shard-A' }) }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc1', requiredShards: ['shard-A'] }),
+        }));
+        await launchApp('app-bc1');
+        expect(getBreadcrumbAppId()).toBe('app-bc1');
+    });
+    it('lingers across returnToHome (does NOT clear like lastAppState)', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        const { readLastApp } = await import('./lifecycle');
+        registerShard(makeShard({ manifest: makeShardManifest({ id: 'shard-A' }) }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc2', requiredShards: ['shard-A'] }),
+        }));
+        await launchApp('app-bc2');
+        await returnToHome();
+        expect(getBreadcrumbAppId()).toBe('app-bc2');
+        expect(readLastApp()).toBeNull();
+    });
+    it('overwrites on a subsequent launch', async () => {
+        const { getBreadcrumbAppId } = await import('./registry.svelte');
+        registerShard(makeShard({ manifest: makeShardManifest({ id: 'shard-A' }) }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc3a', requiredShards: ['shard-A'] }),
+        }));
+        registerApp(makeApp({
+            manifest: makeAppManifest({ id: 'app-bc3b', requiredShards: ['shard-A'] }),
+        }));
+        await launchApp('app-bc3a');
+        await launchApp('app-bc3b');
+        expect(getBreadcrumbAppId()).toBe('app-bc3b');
+    });
+});

package/dist/apps/registry.svelte.d.ts

@@ -13,6 +13,22 @@ export declare const registeredApps: Map<string, App>;
 export declare const activeApp: {
     id: string | null;
 };
+/**
+ * Most recently launched app id this session. Distinct from
+ * `lastAppState` in `lifecycle.ts` (which is persisted to the user zone
+ * for boot, and cleared by `returnToHome`). The breadcrumb pointer
+ * survives `returnToHome` so the top-bar BrandSlot can render
+ * `SH3 > [App Name]` and let the user one-click back into the app.
+ *
+ * In-memory only — page reload resets it to null. No persistence.
+ */
+export declare const breadcrumbApp: {
+    id: string | null;
+};
+/** Read the breadcrumb app id. `null` when no app has launched this session. */
+export declare function getBreadcrumbAppId(): string | null;
+/** @internal — test helper; resets the breadcrumb to null. */
+export declare function __resetBreadcrumbForTest(): void;
 /**
  * Register (or re-register) an app with the framework.
  *
@@ -38,5 +54,5 @@ export declare function getActiveApp(): AppManifest | null;
  * activate hook. Not re-exported through `api.ts`.
  */
 export declare function getRegisteredApp(id: string): App | undefined;
-/** Test-only reset: clear registered apps and the active-app pointer. */
+/** Test-only reset: clear registered apps, active-app pointer, and breadcrumb. */
 export declare function __resetAppRegistryForTest(): void;

package/dist/apps/registry.svelte.js

@@ -20,6 +20,24 @@ export const registeredApps = $state(new Map());
  * most one active app at a time.
  */
 export const activeApp = $state({ id: null });
+/**
+ * Most recently launched app id this session. Distinct from
+ * `lastAppState` in `lifecycle.ts` (which is persisted to the user zone
+ * for boot, and cleared by `returnToHome`). The breadcrumb pointer
+ * survives `returnToHome` so the top-bar BrandSlot can render
+ * `SH3 > [App Name]` and let the user one-click back into the app.
+ *
+ * In-memory only — page reload resets it to null. No persistence.
+ */
+export const breadcrumbApp = $state({ id: null });
+/** Read the breadcrumb app id. `null` when no app has launched this session. */
+export function getBreadcrumbAppId() {
+    return breadcrumbApp.id;
+}
+/** @internal — test helper; resets the breadcrumb to null. */
+export function __resetBreadcrumbForTest() {
+    breadcrumbApp.id = null;
+}
 /**
  * Register (or re-register) an app with the framework.
  *
@@ -57,8 +75,9 @@ export function getActiveApp() {
 export function getRegisteredApp(id) {
     return registeredApps.get(id);
 }
-/** Test-only reset: clear registered apps and the active-app pointer. */
+/** Test-only reset: clear registered apps, active-app pointer, and breadcrumb. */
 export function __resetAppRegistryForTest() {
     registeredApps.clear();
     activeApp.id = null;
+    breadcrumbApp.id = null;
 }

package/dist/apps/types.d.ts

@@ -1,6 +1,28 @@
 import type { LayoutNode, LayoutTree, LayoutPreset } from '../layout/types';
 import type { ZoneSchema, ZoneManager } from '../state/types';
 import type { StateZones } from '../state/zones.svelte';
+/**
+ * One menu bar container ("File", "Edit", etc.). Apps declare these in
+ * `AppManifest.menus`; when omitted, sh3-core uses DEFAULT_MENU_CONTAINERS.
+ * Items reach a container by setting `Action.menuItem` to its `id`.
+ */
+export interface MenuContainer {
+    /** Container id referenced by Action.menuItem. */
+    id: string;
+    /** Display label shown in the menu bar. */
+    label: string;
+    /** Optional lucide icon name. */
+    icon?: string;
+    /** Icon placement relative to the label. Default: 'before'. */
+    iconPosition?: 'before' | 'after';
+    /**
+     * Optional explicit ordering. When omitted, declaration order in the
+     * `AppManifest.menus` array is used. Containers with `order` defined
+     * sort first (ascending); ties and undefined fall back to declaration
+     * order.
+     */
+    order?: number;
+}
 /**
  * Static description of an app as observed by the framework at runtime.
  * `version` is always present here: externally installed apps have it
@@ -46,6 +68,12 @@ export interface AppManifest {
      * in a later plan alongside the server-side sync runtime.
      */
     permissions?: string[];
+    /**
+     * Optional menu bar container list. When present, fully replaces the
+     * canonical fallback (file, edit, view, window, help) for this app.
+     * When absent, the canonical fallback is used. See MenuContainer.
+     */
+    menus?: MenuContainer[];
 }
 /**
  * Context object passed to `App.activate`. Provides app-scoped state zones

package/dist/assets/icons.svg

@@ -653,6 +653,11 @@
     <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" />
   </symbol>
 
+  <!-- lucide/magnet -->
+  <symbol id="magnet" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="m12 15 4 4" /><path d="M2.352 10.648a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l6.029-6.029a1 1 0 1 1 3 3l-6.029 6.029a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l6.365-6.367A1 1 0 0 0 8.716 4.282z" />
+    <path d="m5 8 4 4" />
+  </symbol>  
   <!-- lucide/video -->
   <symbol id="video" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
     <path d="m16 13 5.223 3.482a.5.5 0 0 0 .777-.416V7.87a.5.5 0 0 0-.752-.432L16 10.5" />

package/dist/documents/backends.d.ts

@@ -5,6 +5,7 @@ export declare class MemoryDocumentBackend implements DocumentBackend {
     read(tenantId: string, shardId: string, path: string): Promise<string | ArrayBuffer | null>;
     write(tenantId: string, shardId: string, path: string, content: string | ArrayBuffer): Promise<void>;
     delete(tenantId: string, shardId: string, path: string): Promise<void>;
+    rename(tenantId: string, shardId: string, oldPath: string, newPath: string): Promise<void>;
     list(tenantId: string, shardId: string): Promise<DocumentMeta[]>;
     exists(tenantId: string, shardId: string, path: string): Promise<boolean>;
     listAllShards(tenantId: string): Promise<string[]>;
@@ -18,6 +19,7 @@ export declare class IndexedDBDocumentBackend implements DocumentBackend {
     read(tenantId: string, shardId: string, path: string): Promise<string | ArrayBuffer | null>;
     write(tenantId: string, shardId: string, path: string, content: string | ArrayBuffer): Promise<void>;
     delete(tenantId: string, shardId: string, path: string): Promise<void>;
+    rename(tenantId: string, shardId: string, oldPath: string, newPath: string): Promise<void>;
     list(tenantId: string, shardId: string): Promise<DocumentMeta[]>;
     exists(tenantId: string, shardId: string, path: string): Promise<boolean>;
     listAllShards(tenantId: string): Promise<string[]>;

package/dist/documents/backends.js

@@ -45,6 +45,19 @@ export class MemoryDocumentBackend {
     async delete(tenantId, shardId, path) {
         __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").delete(compositeKey(tenantId, shardId, path));
     }
+    async rename(tenantId, shardId, oldPath, newPath) {
+        const oldKey = compositeKey(tenantId, shardId, oldPath);
+        const newKey = compositeKey(tenantId, shardId, newPath);
+        const entry = __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").get(oldKey);
+        if (!entry) {
+            throw new Error(`Document not found at ${oldPath}`);
+        }
+        if (__classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").has(newKey)) {
+            throw new Error(`Document already exists at ${newPath}`);
+        }
+        __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").set(newKey, Object.assign(Object.assign({}, entry), { lastModified: Date.now() }));
+        __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").delete(oldKey);
+    }
     async list(tenantId, shardId) {
         const prefix = keyPrefix(tenantId, shardId);
         const out = [];
@@ -126,6 +139,48 @@ export class IndexedDBDocumentBackend {
         const key = compositeKey(tenantId, shardId, path);
         await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readwrite', (s) => s.delete(key));
     }
+    async rename(tenantId, shardId, oldPath, newPath) {
+        const oldKey = compositeKey(tenantId, shardId, oldPath);
+        const newKey = compositeKey(tenantId, shardId, newPath);
+        const db = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this);
+        return new Promise((resolve, reject) => {
+            let aborted = false;
+            const tx = db.transaction(IDB_STORE, 'readwrite');
+            const store = tx.objectStore(IDB_STORE);
+            const getOld = store.get(oldKey);
+            getOld.onsuccess = () => {
+                const entry = getOld.result;
+                if (!entry) {
+                    aborted = true;
+                    tx.abort();
+                    reject(new Error(`Document not found at ${oldPath}`));
+                    return;
+                }
+                const getNew = store.getKey(newKey);
+                getNew.onsuccess = () => {
+                    if (getNew.result !== undefined) {
+                        aborted = true;
+                        tx.abort();
+                        reject(new Error(`Document already exists at ${newPath}`));
+                        return;
+                    }
+                    const renamed = Object.assign(Object.assign({}, entry), { lastModified: Date.now() });
+                    store.put(renamed, newKey);
+                    store.delete(oldKey);
+                };
+                getNew.onerror = () => reject(getNew.error);
+            };
+            getOld.onerror = () => reject(getOld.error);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => {
+                if (!aborted)
+                    reject(tx.error);
+            };
+            tx.onabort = () => {
+                // Already rejected above; swallow.
+            };
+        });
+    }
     async list(tenantId, shardId) {
         const prefix = keyPrefix(tenantId, shardId);
         const db = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this);

package/dist/documents/backends.test.d.ts

@@ -1 +1 @@
-export {};
+import 'fake-indexeddb/auto';