sh3-core 0.15.0 → 0.15.2

package/dist/layouts-shard/layoutsApi.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { floatManager, __resetFloatManagerForTest } from '../overlays/float';
+import { captureFromFloat, restoreToFloat } from './layoutsApi';
+const STANDALONE = new Set(['shell:terminal', 'graphlive:hierarchy']);
+const isStandalone = (id) => STANDALONE.has(id);
+describe('captureFromFloat', () => {
+    beforeEach(() => __resetFloatManagerForTest());
+    it('returns null for an unknown floatId', () => {
+        const out = captureFromFloat('nope', isStandalone);
+        expect(out).toBeNull();
+    });
+    it('returns null when filter empties the float', () => {
+        const id = floatManager.openWithContent({
+            content: { type: 'slot', slotId: 's', viewId: 'app-only:view' },
+            size: { w: 600, h: 400 },
+        });
+        expect(captureFromFloat(id, isStandalone)).toBeNull();
+    });
+    it('returns a clone of the filtered tree (mutating result must not affect source)', () => {
+        const content = {
+            type: 'tabs',
+            activeTab: 0,
+            tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+        };
+        const id = floatManager.openWithContent({ content, size: { w: 700, h: 500 } });
+        const out = captureFromFloat(id, isStandalone);
+        expect(out).not.toBeNull();
+        expect(out.size).toEqual({ w: 700, h: 500 });
+        expect(out.content).toEqual(content);
+        // Mutate the returned content; verify the float entry is unaffected.
+        if (out.content.type === 'tabs')
+            out.content.tabs[0].label = 'MUTATED';
+        const live = floatManager.list().find((f) => f.id === id);
+        if (live.content.type === 'tabs') {
+            expect(live.content.tabs[0].label).toBe('Shell');
+        }
+    });
+});
+describe('restoreToFloat', () => {
+    beforeEach(() => __resetFloatManagerForTest());
+    function mk(content) {
+        return {
+            id: 'sl-1',
+            name: 'My Layout',
+            createdAt: 0,
+            size: { w: 720, h: 480 },
+            content,
+        };
+    }
+    it('returns empty string + does not open a float when filter empties', () => {
+        const toast = vi.fn();
+        const layout = mk({ type: 'slot', slotId: 's', viewId: 'app-only:view' });
+        const id = restoreToFloat(layout, isStandalone, toast);
+        expect(id).toBe('');
+        expect(floatManager.list()).toHaveLength(0);
+        expect(toast).toHaveBeenCalledWith(expect.stringContaining('My Layout'), 'warn');
+    });
+    it('opens a float with the filtered content and returns its id', () => {
+        const toast = vi.fn();
+        const layout = mk({
+            type: 'tabs',
+            activeTab: 0,
+            tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+        });
+        const id = restoreToFloat(layout, isStandalone, toast);
+        expect(id).not.toBe('');
+        const list = floatManager.list();
+        expect(list).toHaveLength(1);
+        expect(list[0].id).toBe(id);
+        expect(list[0].title).toBe('My Layout');
+        expect(list[0].size).toEqual({ w: 720, h: 480 });
+        expect(toast).not.toHaveBeenCalled();
+    });
+});

package/dist/layouts-shard/layoutsShard.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Shard } from '../shards/types';
+import type { SavedLayout } from './types';
+export declare function __testSaveLayout(floatId: string, name: string): SavedLayout | null;
+export declare function __testCustomize(layoutId: string, next: {
+    label: string;
+    icon?: string;
+    color?: string;
+}): void;
+export declare function __testCustomizeReset(layoutId: string): void;
+export declare function __testDelete(layoutId: string): void;
+export declare const layoutsShard: Shard;

package/dist/layouts-shard/layoutsShard.svelte.js

@@ -0,0 +1,231 @@
+/*
+ * `__layouts__` shard — saved-layout capture-and-restore.
+ *
+ * Owns the user-zone for SavedLayout records, contributes the
+ * `sh3.layout.save` action under element:float-header (handler resolves
+ * the target floatId from the typed selection set by FloatFrame's
+ * oncontextmenu), and (in later tasks) the open-saved-layout palette
+ * submenu and the home-page card grid.
+ */
+import { VERSION } from '../version';
+import { listStandaloneViews } from '../shards/activate.svelte';
+import { getSelection } from '../actions/selection.svelte';
+import { modalManager } from '../overlays/modal';
+import { toastManager } from '../overlays/toast';
+import LayoutSaveModal from './LayoutSaveModal.svelte';
+import EntityAppearanceModal from '../overlays/EntityAppearanceModal.svelte';
+import { __bindZone, __unbindZone, addLayout, deleteLayout, getLayouts, updateLayout, } from './layoutsState.svelte';
+import ConfirmDialog from '../overlays/ConfirmDialog.svelte';
+import { captureFromFloat, restoreToFloat } from './layoutsApi';
+function readFloatHeaderRef() {
+    const sel = getSelection();
+    if (!sel || sel.type !== 'float-header')
+        return null;
+    return sel.ref;
+}
+function isStandalone(viewId) {
+    return listStandaloneViews().some((v) => v.viewId === viewId);
+}
+function resolveViewLabel(viewId) {
+    var _a, _b;
+    return (_b = (_a = listStandaloneViews().find((v) => v.viewId === viewId)) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : viewId;
+}
+function generateLayoutId() {
+    return `sl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * Effectful save path. Exposed as `__testSaveLayout` for unit tests so they
+ * don't need to mount the modal. Production path runs through the modal,
+ * which calls this same function via its onConfirm callback.
+ */
+function performSave(floatId, name) {
+    const captured = captureFromFloat(floatId, isStandalone);
+    if (captured === null)
+        return null;
+    const layout = {
+        id: generateLayoutId(),
+        name,
+        createdAt: Date.now(),
+        size: captured.size,
+        content: captured.content,
+    };
+    addLayout(layout);
+    return layout;
+}
+export function __testSaveLayout(floatId, name) {
+    return performSave(floatId, name);
+}
+function readSavedLayoutRef() {
+    const sel = getSelection();
+    if (!sel || sel.type !== 'saved-layout')
+        return null;
+    return sel.ref;
+}
+function performCustomize(layoutId, next) {
+    const appearance = next.icon === undefined && next.color === undefined
+        ? undefined
+        : { icon: next.icon, color: next.color };
+    updateLayout(layoutId, {
+        name: next.label,
+        appearance,
+    });
+}
+function performCustomizeReset(layoutId) {
+    updateLayout(layoutId, { appearance: undefined });
+}
+export function __testCustomize(layoutId, next) {
+    performCustomize(layoutId, next);
+}
+export function __testCustomizeReset(layoutId) {
+    performCustomizeReset(layoutId);
+}
+function runCustomize(_ctx) {
+    const ref = readSavedLayoutRef();
+    if (!ref)
+        return;
+    const layout = getLayouts().find((l) => l.id === ref.layoutId);
+    if (!layout)
+        return;
+    const props = {
+        entityLabel: layout.name,
+        initialAppearance: layout.appearance,
+        defaultIcon: 'eye',
+        requireLabel: true,
+        onSave: (next) => performCustomize(ref.layoutId, next),
+        onReset: () => performCustomizeReset(ref.layoutId),
+    };
+    modalManager.open(EntityAppearanceModal, props);
+}
+function performDelete(layoutId) {
+    deleteLayout(layoutId);
+}
+export function __testDelete(layoutId) {
+    performDelete(layoutId);
+}
+function runDelete(_ctx) {
+    const ref = readSavedLayoutRef();
+    if (!ref)
+        return;
+    const layout = getLayouts().find((l) => l.id === ref.layoutId);
+    if (!layout)
+        return;
+    modalManager.open(ConfirmDialog, {
+        title: `Delete saved layout "${layout.name}"?`,
+        body: 'This cannot be undone.',
+        confirmLabel: 'Delete',
+        confirmTone: 'danger',
+        onConfirm: () => performDelete(ref.layoutId),
+    });
+}
+function runSave(_ctx) {
+    const ref = readFloatHeaderRef();
+    if (!ref)
+        return;
+    const props = {
+        floatId: ref.floatId,
+        isStandalone,
+        resolveLabel: resolveViewLabel,
+        defaultName: `Layout ${getLayouts().length + 1}`,
+        onConfirm: (name) => { performSave(ref.floatId, name); },
+    };
+    modalManager.open(LayoutSaveModal, props);
+}
+export const layoutsShard = {
+    manifest: {
+        id: '__layouts__',
+        label: 'Saved Layouts',
+        version: VERSION,
+        views: [],
+    },
+    activate(ctx) {
+        const zone = ctx.state({
+            user: { layouts: [] },
+        });
+        __bindZone(zone);
+        const toast = (m, level) => {
+            toastManager.notify(m, { level });
+        };
+        const save = {
+            id: 'sh3.layout.save',
+            label: 'Save layout as…',
+            scope: { element: 'float-header' },
+            contextItem: true,
+            paletteItem: false,
+            run: runSave,
+        };
+        ctx.actions.register(save);
+        // Submenu parent. The dispatcher's default behavior on a parent
+        // without a run() opens a sub-palette filtered to its children.
+        ctx.actions.register({
+            id: 'sh3.layout.open',
+            label: 'Open saved layout',
+            scope: ['home', 'app'],
+            submenu: true,
+            paletteItem: true,
+        });
+        ctx.actions.register({
+            id: 'sh3.layout.customize',
+            label: 'Customize…',
+            scope: { element: 'saved-layout' },
+            contextItem: true,
+            group: 'appearance',
+            run: runCustomize,
+        });
+        ctx.actions.register({
+            id: 'sh3.layout.delete',
+            label: 'Delete',
+            scope: { element: 'saved-layout' },
+            contextItem: true,
+            run: runDelete,
+        });
+        // Dynamic children — one per saved layout, kept in sync as layouts
+        // are added / renamed / removed. Identical pattern to sh3.app.launch
+        // in sh3coreShard.svelte.ts, plus rename detection via a sidecar
+        // label map so the registered child label tracks the saved name.
+        const openUnregisters = new Map();
+        const registeredLabels = new Map();
+        $effect.root(() => {
+            $effect(() => {
+                const layouts = getLayouts();
+                const currentIds = new Set();
+                for (const layout of layouts) {
+                    currentIds.add(layout.id);
+                    const existing = openUnregisters.get(layout.id);
+                    if (existing && registeredLabels.get(layout.id) === layout.name)
+                        continue;
+                    if (existing) {
+                        existing();
+                        openUnregisters.delete(layout.id);
+                        registeredLabels.delete(layout.id);
+                    }
+                    const off = ctx.actions.register({
+                        id: `sh3.layout.open:${layout.id}`,
+                        label: layout.name,
+                        scope: ['home', 'app'],
+                        submenuOf: 'sh3.layout.open',
+                        run: () => {
+                            const live = getLayouts().find((l) => l.id === layout.id);
+                            if (live)
+                                restoreToFloat(live, isStandalone, toast);
+                        },
+                    });
+                    openUnregisters.set(layout.id, off);
+                    registeredLabels.set(layout.id, layout.name);
+                }
+                for (const id of [...openUnregisters.keys()]) {
+                    if (!currentIds.has(id)) {
+                        openUnregisters.get(id)();
+                        openUnregisters.delete(id);
+                        registeredLabels.delete(id);
+                    }
+                }
+            });
+        });
+    },
+    autostart() {
+        /* self-start so the action is available before any app launches. */
+    },
+    deactivate() {
+        __unbindZone();
+    },
+};

package/dist/layouts-shard/layoutsShard.svelte.test.d.ts

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

package/dist/layouts-shard/layoutsShard.svelte.test.js

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registerShard, activateShard } from '../shards/activate.svelte';
+import { addAutostartShard } from '../actions/state.svelte';
+import { floatManager } from '../overlays/float';
+import { layoutsShard } from './layoutsShard.svelte';
+import { __resetForTests, getLayouts } from './layoutsState.svelte';
+import { __resetActionsRegistryForTest } from '../actions/registry';
+import { resetFramework } from '../__test__/reset';
+// Minimal stub shard exposing one standalone view, so listStandaloneViews()
+// returns something useful inside this test file.
+const stubShard = {
+    manifest: {
+        id: 'stub',
+        label: 'Stub',
+        version: '0.0.0',
+        views: [{ id: 'shell:terminal', label: 'Shell', standalone: true }],
+    },
+    activate(ctx) {
+        ctx.registerView('shell:terminal', {
+            mount: () => ({ unmount() { } }),
+        });
+    },
+};
+describe('layoutsShard — sh3.layout.save', () => {
+    beforeEach(async () => {
+        resetFramework();
+        __resetActionsRegistryForTest();
+        __resetForTests();
+        registerShard(stubShard);
+        addAutostartShard(stubShard.manifest.id);
+        await activateShard(stubShard.manifest.id);
+        registerShard(layoutsShard);
+        addAutostartShard(layoutsShard.manifest.id);
+        await activateShard(layoutsShard.manifest.id);
+    });
+    it('registers sh3.layout.save against element:float-header', async () => {
+        const { listActions } = await import('../actions/registry');
+        const entries = listActions();
+        const save = entries.find((e) => e.action.id === 'sh3.layout.save');
+        expect(save).toBeDefined();
+        expect(JSON.stringify(save.action.scope)).toContain('float-header');
+    });
+    it('persists a captured layout to the user zone via the save flow', async () => {
+        const floatId = floatManager.openWithContent({
+            content: {
+                type: 'tabs',
+                activeTab: 0,
+                tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+            },
+            size: { w: 800, h: 600 },
+        });
+        const { __testSaveLayout } = await import('./layoutsShard.svelte');
+        __testSaveLayout(floatId, 'My Saved Layout');
+        const layouts = getLayouts();
+        expect(layouts).toHaveLength(1);
+        expect(layouts[0].name).toBe('My Saved Layout');
+        expect(layouts[0].size).toEqual({ w: 800, h: 600 });
+        expect(layouts[0].content).toMatchObject({
+            type: 'tabs',
+            tabs: [{ viewId: 'shell:terminal' }],
+        });
+    });
+});
+describe('layoutsShard — sh3.layout.open palette submenu', () => {
+    beforeEach(async () => {
+        resetFramework();
+        __resetActionsRegistryForTest();
+        __resetForTests();
+        registerShard(stubShard);
+        addAutostartShard(stubShard.manifest.id);
+        await activateShard(stubShard.manifest.id);
+        registerShard(layoutsShard);
+        addAutostartShard(layoutsShard.manifest.id);
+        await activateShard(layoutsShard.manifest.id);
+    });
+    it('registers sh3.layout.open as a submenu parent', async () => {
+        const { listActions } = await import('../actions/registry');
+        const entry = listActions().find((e) => e.action.id === 'sh3.layout.open');
+        expect(entry).toBeDefined();
+        expect(entry.action.submenu).toBe(true);
+        expect(entry.action.paletteItem).toBe(true);
+    });
+    it('registers a dynamic child per saved layout under sh3.layout.open', async () => {
+        const { __testSaveLayout } = await import('./layoutsShard.svelte');
+        const floatId = floatManager.openWithContent({
+            content: {
+                type: 'tabs',
+                activeTab: 0,
+                tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+            },
+            size: { w: 600, h: 400 },
+        });
+        __testSaveLayout(floatId, 'Workspace A');
+        const { listActions } = await import('../actions/registry');
+        const child = listActions().find((e) => e.action.submenuOf === 'sh3.layout.open' && e.action.label === 'Workspace A');
+        expect(child).toBeDefined();
+    });
+    it('restores the saved layout into a fresh float when its child is run', async () => {
+        const { __testSaveLayout } = await import('./layoutsShard.svelte');
+        const sourceId = floatManager.openWithContent({
+            content: {
+                type: 'tabs',
+                activeTab: 0,
+                tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+            },
+            size: { w: 720, h: 480 },
+        });
+        const layout = __testSaveLayout(sourceId, 'Workspace A');
+        floatManager.close(sourceId);
+        expect(floatManager.list()).toHaveLength(0);
+        const { listActions } = await import('../actions/registry');
+        const child = listActions().find((e) => e.action.id === `sh3.layout.open:${layout.id}`);
+        await child.action.run({
+            action: { id: child.action.id, label: 'Workspace A' },
+            appId: null,
+            invokedVia: 'palette',
+            dispatch: () => { },
+        });
+        const list = floatManager.list();
+        expect(list).toHaveLength(1);
+        expect(list[0].title).toBe('Workspace A');
+        expect(list[0].size).toEqual({ w: 720, h: 480 });
+    });
+});
+describe('layoutsShard — sh3.layout.customize', () => {
+    beforeEach(async () => {
+        resetFramework();
+        __resetActionsRegistryForTest();
+        __resetForTests();
+        registerShard(stubShard);
+        addAutostartShard(stubShard.manifest.id);
+        await activateShard(stubShard.manifest.id);
+        registerShard(layoutsShard);
+        addAutostartShard(layoutsShard.manifest.id);
+        await activateShard(layoutsShard.manifest.id);
+    });
+    it('rename via __testCustomize updates the layout name and palette child label', async () => {
+        const { __testSaveLayout, __testCustomize } = await import('./layoutsShard.svelte');
+        const sourceId = floatManager.openWithContent({
+            content: {
+                type: 'tabs',
+                activeTab: 0,
+                tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+            },
+            size: { w: 600, h: 400 },
+        });
+        const layout = __testSaveLayout(sourceId, 'Original');
+        __testCustomize(layout.id, { label: 'Renamed', icon: 'cog', color: '#abc' });
+        const after = getLayouts().find((l) => l.id === layout.id);
+        expect(after.name).toBe('Renamed');
+        expect(after.appearance).toEqual({ icon: 'cog', color: '#abc' });
+        const { listActions } = await import('../actions/registry');
+        const child = listActions().find((e) => e.action.id === `sh3.layout.open:${layout.id}`);
+        expect(child).toBeDefined();
+        expect(child.action.label).toBe('Renamed');
+    });
+    it('reset via __testCustomizeReset clears appearance but keeps name', async () => {
+        const { __testSaveLayout, __testCustomize, __testCustomizeReset } = await import('./layoutsShard.svelte');
+        const sourceId = floatManager.openWithContent({
+            content: {
+                type: 'tabs',
+                activeTab: 0,
+                tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+            },
+            size: { w: 600, h: 400 },
+        });
+        const layout = __testSaveLayout(sourceId, 'Original');
+        __testCustomize(layout.id, { label: 'Renamed', icon: 'cog', color: '#abc' });
+        __testCustomizeReset(layout.id);
+        const after = getLayouts().find((l) => l.id === layout.id);
+        expect(after.name).toBe('Renamed');
+        expect(after.appearance).toBeUndefined();
+    });
+    it('registers sh3.layout.customize against element:saved-layout', async () => {
+        const { listActions } = await import('../actions/registry');
+        const entry = listActions().find((e) => e.action.id === 'sh3.layout.customize');
+        expect(entry).toBeDefined();
+        expect(JSON.stringify(entry.action.scope)).toContain('saved-layout');
+    });
+});
+describe('layoutsShard — sh3.layout.delete', () => {
+    beforeEach(async () => {
+        resetFramework();
+        __resetActionsRegistryForTest();
+        __resetForTests();
+        registerShard(stubShard);
+        addAutostartShard(stubShard.manifest.id);
+        await activateShard(stubShard.manifest.id);
+        registerShard(layoutsShard);
+        addAutostartShard(layoutsShard.manifest.id);
+        await activateShard(layoutsShard.manifest.id);
+    });
+    it('removes the layout record and unregisters its palette child', async () => {
+        const { __testSaveLayout, __testDelete } = await import('./layoutsShard.svelte');
+        const sourceId = floatManager.openWithContent({
+            content: {
+                type: 'tabs',
+                activeTab: 0,
+                tabs: [{ slotId: 's', viewId: 'shell:terminal', label: 'Shell' }],
+            },
+            size: { w: 600, h: 400 },
+        });
+        const layout = __testSaveLayout(sourceId, 'Doomed');
+        __testDelete(layout.id);
+        expect(getLayouts().find((l) => l.id === layout.id)).toBeUndefined();
+        const { listActions } = await import('../actions/registry');
+        expect(listActions().find((e) => e.action.id === `sh3.layout.open:${layout.id}`)).toBeUndefined();
+    });
+    it('registers sh3.layout.delete against element:saved-layout', async () => {
+        const { listActions } = await import('../actions/registry');
+        const entry = listActions().find((e) => e.action.id === 'sh3.layout.delete');
+        expect(entry).toBeDefined();
+        expect(JSON.stringify(entry.action.scope)).toContain('saved-layout');
+    });
+});

package/dist/layouts-shard/layoutsState.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { StateZones } from '../state/zones.svelte';
+import type { LayoutsZoneSchema, SavedLayout } from './types';
+export declare function __bindZone(s: StateZones<LayoutsZoneSchema>): void;
+export declare function __unbindZone(): void;
+export declare function getLayouts(): SavedLayout[];
+export declare function addLayout(layout: SavedLayout): void;
+export declare function updateLayout(id: string, patch: Partial<SavedLayout>): void;
+export declare function deleteLayout(id: string): void;
+export declare function __resetForTests(): void;

package/dist/layouts-shard/layoutsState.svelte.js

@@ -0,0 +1,50 @@
+/*
+ * Reactive store for the layouts shard's user-zone proxy. Lives apart from
+ * the shard so unit tests can exercise CRUD without booting a real
+ * ShardContext, mirroring the pattern in app-appearance/appearanceState.
+ *
+ * Production: __bindZone() in layoutsShard.activate() swaps the memory
+ * shim for the live createStateZones-backed user proxy. Reactivity flows
+ * through the underlying $state — readers (LayoutsSection, palette
+ * children) re-derive when the array changes.
+ */
+let zoneState = null;
+export function __bindZone(s) {
+    zoneState = s;
+}
+export function __unbindZone() {
+    zoneState = null;
+}
+export function getLayouts() {
+    var _a;
+    return (_a = zoneState === null || zoneState === void 0 ? void 0 : zoneState.user.layouts) !== null && _a !== void 0 ? _a : [];
+}
+export function addLayout(layout) {
+    if (!zoneState)
+        return;
+    zoneState.user.layouts = [...zoneState.user.layouts, layout];
+}
+export function updateLayout(id, patch) {
+    if (!zoneState)
+        return;
+    const idx = zoneState.user.layouts.findIndex((l) => l.id === id);
+    if (idx < 0)
+        return;
+    const next = [...zoneState.user.layouts];
+    next[idx] = Object.assign(Object.assign({}, next[idx]), patch);
+    zoneState.user.layouts = next;
+}
+export function deleteLayout(id) {
+    if (!zoneState)
+        return;
+    zoneState.user.layouts = zoneState.user.layouts.filter((l) => l.id !== id);
+}
+export function __resetForTests() {
+    zoneState = {
+        ephemeral: {},
+        session: {},
+        workspace: {},
+        user: { layouts: [] },
+    };
+}
+__resetForTests();

package/dist/layouts-shard/layoutsState.test.d.ts

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

package/dist/layouts-shard/layoutsState.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { getLayouts, addLayout, updateLayout, deleteLayout, __resetForTests, } from './layoutsState.svelte';
+function mk(id, name = id) {
+    return {
+        id,
+        name,
+        createdAt: 0,
+        size: { w: 600, h: 400 },
+        content: { type: 'slot', slotId: id, viewId: 'shell:terminal' },
+    };
+}
+describe('layoutsState', () => {
+    beforeEach(() => __resetForTests());
+    it('returns an empty list initially', () => {
+        expect(getLayouts()).toEqual([]);
+    });
+    it('addLayout appends', () => {
+        addLayout(mk('a'));
+        addLayout(mk('b'));
+        expect(getLayouts().map((l) => l.id)).toEqual(['a', 'b']);
+    });
+    it('updateLayout merges fields by id', () => {
+        var _a;
+        addLayout(mk('a', 'original'));
+        updateLayout('a', { name: 'renamed', appearance: { color: '#abc' } });
+        const after = getLayouts()[0];
+        expect(after.name).toBe('renamed');
+        expect((_a = after.appearance) === null || _a === void 0 ? void 0 : _a.color).toBe('#abc');
+        // Untouched fields preserved
+        expect(after.size).toEqual({ w: 600, h: 400 });
+    });
+    it('deleteLayout removes by id', () => {
+        addLayout(mk('a'));
+        addLayout(mk('b'));
+        deleteLayout('a');
+        expect(getLayouts().map((l) => l.id)).toEqual(['b']);
+    });
+    it('updateLayout is a no-op for an unknown id', () => {
+        addLayout(mk('a'));
+        updateLayout('nope', { name: 'x' });
+        expect(getLayouts()[0].name).toBe('a');
+    });
+});

package/dist/layouts-shard/types.d.ts

@@ -0,0 +1,21 @@
+import type { LayoutNode } from '../layout/types';
+export interface SavedLayoutAppearance {
+    color?: string;
+    icon?: string;
+}
+export interface SavedLayout {
+    id: string;
+    name: string;
+    createdAt: number;
+    appearance?: SavedLayoutAppearance;
+    size: {
+        w: number;
+        h: number;
+    };
+    content: LayoutNode;
+}
+export interface LayoutsZoneSchema {
+    user: {
+        layouts: SavedLayout[];
+    };
+}

package/dist/layouts-shard/types.js

@@ -0,0 +1,6 @@
+/*
+ * SavedLayout — capture-and-restore record for a free-form view
+ * arrangement built inside a float. See
+ * docs/superpowers/specs/2026-05-08-saved-layouts-design.md.
+ */
+export {};