sh3-core 0.21.0 → 0.22.0

package/dist/documents/handle.test.js

@@ -251,3 +251,66 @@ describe('DocumentHandle folder ops', () => {
         ]);
     });
 });
+describe('createDocumentHandle — appId override', () => {
+    it('uses appId as the namespace root when provided', async () => {
+        const backend = new MemoryDocumentBackend();
+        const handle = createDocumentHandle('tenant-1', 'sh3-editor', backend, { format: 'text', appId: 'guml-ide' });
+        await handle.write('test.guml', 'content');
+        const keysAppId = await backend.list('tenant-1', 'guml-ide');
+        expect(keysAppId.some((k) => k.path === 'test.guml')).toBe(true);
+        const keysShardId = await backend.list('tenant-1', 'sh3-editor');
+        expect(keysShardId).toHaveLength(0);
+    });
+    it('falls back to shardId when appId is not provided', async () => {
+        const backend = new MemoryDocumentBackend();
+        const handle = createDocumentHandle('tenant-1', 'sh3-editor', backend, { format: 'text' });
+        await handle.write('test.guml', 'content');
+        const keys = await backend.list('tenant-1', 'sh3-editor');
+        expect(keys.some((k) => k.path === 'test.guml')).toBe(true);
+    });
+});
+describe('createDocumentHandle — lazy resolvers', () => {
+    it('resolves namespace per operation from a function', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        let ns = 'shard-A';
+        const handle = createDocumentHandle('local', () => ns, backend, { format: 'text' });
+        await handle.write('foo.txt', 'first');
+        expect((await backend.list('local', 'shard-A')).map(d => d.path)).toContain('foo.txt');
+        ns = 'app-X';
+        await handle.write('bar.txt', 'second');
+        expect((await backend.list('local', 'app-X')).map(d => d.path)).toContain('bar.txt');
+        expect((await backend.list('local', 'shard-A')).map(d => d.path)).not.toContain('bar.txt');
+    });
+    it('resolves tenant per operation from a function', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        let tenant = 'alice';
+        const handle = createDocumentHandle(() => tenant, () => 'shard-A', backend, { format: 'text' });
+        await handle.write('p.txt', 'a');
+        expect((await backend.list('alice', 'shard-A')).map(d => d.path)).toContain('p.txt');
+        tenant = 'bob';
+        await handle.write('q.txt', 'b');
+        expect((await backend.list('bob', 'shard-A')).map(d => d.path)).toContain('q.txt');
+    });
+    it('watchers resolve namespace at emit time, not subscribe time', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        let ns = 'shard-A';
+        const handle = createDocumentHandle('local', () => ns, backend, { format: 'text' });
+        const seen = [];
+        handle.watch((c) => seen.push(`${c.type}:${c.path}`));
+        await handle.write('a.txt', 'x');
+        ns = 'app-X';
+        await handle.write('b.txt', 'y');
+        expect(seen).toContain('create:a.txt');
+        expect(seen).toContain('create:b.txt');
+    });
+    it('still accepts string tenant + namespace for back-compat', async () => {
+        const { MemoryDocumentBackend } = await import('./backends');
+        const backend = new MemoryDocumentBackend();
+        const handle = createDocumentHandle('local', 'shard-A', backend, { format: 'text' });
+        await handle.write('foo.txt', 'hi');
+        expect((await backend.list('local', 'shard-A')).map(d => d.path)).toContain('foo.txt');
+    });
+});

package/dist/documents/types.d.ts

@@ -50,6 +50,12 @@ export interface DocumentHandleOptions {
     format: DocumentFormat;
     /** File extensions this handle operates on, e.g. ['.guml', '.md']. */
     extensions?: string[];
+    /**
+     * When set, this handle's namespace root becomes `{scope}/docs/{appId}/`
+     * instead of `{scope}/docs/{shardId}/`. Use in `onAppActivate` to get
+     * a handle scoped to the app's shared document namespace.
+     */
+    appId?: string;
 }
 /** Metadata about a stored document. */
 export interface DocumentMeta {

package/dist/layout/LayoutRenderer.svelte

@@ -227,7 +227,7 @@
         {#if entry}
           <div class="tab-slot-wrapper">
             <SlotContainer
-              node={{ type: 'slot', slotId: entry.slotId, viewId: entry.viewId }}
+              node={{ type: 'slot', slotId: entry.slotId, viewId: entry.viewId, props: entry.props }}
               label={entry.label}
               meta={entry.meta}
             />

package/dist/layout/SlotContainer.svelte

@@ -71,6 +71,7 @@
       node.viewId,
       label || node.viewId || currentSlotId,
       meta,
+      node.props,
     );
     wrapperEl.appendChild(host);
 

package/dist/layout/inspection.js

@@ -14,7 +14,7 @@
  */
 import { activeLayout, getActiveRoot } from './store.svelte';
 import { nodeAtPath, findTabBySlotId, removeTabBySlotId, cleanupTree, splitNodeAtPath, locateSlotIn, } from './ops';
-import { getSlotHandle } from './slotHostPool.svelte';
+import { getSlotHandle, isSlotClosable } from './slotHostPool.svelte';
 import { floatManager } from '../overlays/float';
 import { viewportStore } from '../viewport/store.svelte';
 import { compactRootStore } from './compact/rootStore.svelte';
@@ -160,14 +160,15 @@ export async function closeTab(slotId) {
     if (!located) {
         return closeFloatTab(tree, slotId);
     }
-    const handle = getSlotHandle(slotId);
-    const closable = handle === null || handle === void 0 ? void 0 : handle.closable;
-    // Non-closable: no action.
-    if (!closable)
+    // Use the same closability signal that drives the close button in the UI.
+    // This covers standalone: and float: prefixed slots that are auto-closable
+    // even when the view handle does not explicitly declare closable: true.
+    if (!isSlotClosable(slotId))
         return false;
-    // Guarded: ask the shard.
-    if (typeof closable === 'object') {
-        const allowed = await closable.canClose();
+    // Guarded: ask the shard if it declared a canClose() guard.
+    const handle = getSlotHandle(slotId);
+    if (typeof (handle === null || handle === void 0 ? void 0 : handle.closable) === 'object') {
+        const allowed = await handle.closable.canClose();
         if (!allowed)
             return false;
         // Re-verify the tab still exists after the async gap — another close
@@ -237,9 +238,10 @@ export function popoutView(slotId) {
         return null;
     const title = entry.label;
     const meta = entry.meta;
+    const props = entry.props;
     removeTabBySlotId(tree.docked, slotId);
     cleanupTree(tree.docked);
-    return floatManager.open(viewId, { title, meta });
+    return floatManager.open(viewId, { title, meta, props });
 }
 /**
  * Dock a float back into the currently-rendered layout. The float's
@@ -260,15 +262,18 @@ export function dockFloat(floatId) {
         return false;
     }
     const entry = (_b = tabs.tabs[(_a = tabs.activeTab) !== null && _a !== void 0 ? _a : 0]) !== null && _b !== void 0 ? _b : tabs.tabs[0];
-    const ok = dockIntoActiveLayout({
+    const newEntry = {
         slotId: entry.slotId,
         viewId: entry.viewId,
         label: entry.label,
         meta: entry.meta,
-    });
-    if (ok)
-        floatManager.close(floatId);
-    return ok;
+        props: entry.props,
+    };
+    // Close the float BEFORE inserting so dockIntoActiveLayout's internal
+    // focusView() doesn't find the float's own tab and short-circuit the
+    // actual insert. The captured `newEntry` keeps the data we need.
+    floatManager.close(floatId);
+    return dockIntoActiveLayout(newEntry);
 }
 function findFirstTabsNode(node) {
     if (node.type === 'tabs')

package/dist/layout/inspection.svelte.test.js

@@ -7,7 +7,7 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { flushSync } from 'svelte';
 import { attachApp, switchToApp, __resetLayoutStoreForTest, layoutStore, } from './store.svelte';
-import { dockIntoActiveLayout } from './inspection';
+import { dockIntoActiveLayout, inspectActiveLayout } from './inspection';
 let appCounter = 0;
 function makeApp(initialLayout) {
     // Unique id per call so workspace-zone storage from one test doesn't
@@ -161,3 +161,138 @@ describe('focusView — compact body-root swap', () => {
         viewportStore.override(null);
     });
 });
+// ---------------------------------------------------------------------------
+// closeTab — standalone prefix makes tab closable regardless of view handle
+// ---------------------------------------------------------------------------
+import { closeTab, spliceIntoActiveLayout } from './inspection';
+import { acquireSlotHost, resetSlotHostPool } from './slotHostPool.svelte';
+import { registerView } from '../shards/registry';
+import { __resetViewRegistryForTest } from '../shards/registry';
+describe('spliceIntoActiveLayout — props stored on tab entry', () => {
+    beforeEach(() => {
+        __resetLayoutStoreForTest();
+    });
+    it('stores props on the new tab entry', () => {
+        attachApp(makeApp({
+            type: 'tabs',
+            tabs: [{ slotId: 'existing', viewId: 'v:existing', label: 'Existing' }],
+            activeTab: 0,
+        }));
+        switchToApp();
+        spliceIntoActiveLayout({
+            slotId: 'my-slot',
+            viewId: 'test:view',
+            label: 'Test',
+            props: { filePath: '/foo.guml' },
+        });
+        const { root } = inspectActiveLayout();
+        const tabs = root.docked;
+        if (tabs.type !== 'tabs')
+            throw new Error('expected tabs root');
+        const tab = tabs.tabs.find(t => t.slotId === 'my-slot');
+        expect(tab === null || tab === void 0 ? void 0 : tab.props).toEqual({ filePath: '/foo.guml' });
+    });
+});
+describe('popoutView / dockFloat — props round-trip', () => {
+    beforeEach(() => {
+        __resetLayoutStoreForTest();
+        __resetFloatManagerForTest();
+        bindFloatStore(layoutStore.floats, () => ({ w: 1024, h: 768 }));
+    });
+    it('popoutView preserves tab.props on the resulting float entry', async () => {
+        var _a;
+        const { popoutView } = await import('./inspection');
+        attachApp(makeApp({
+            type: 'tabs',
+            tabs: [
+                {
+                    slotId: 'with-props',
+                    viewId: 'editor:view',
+                    label: 'My File',
+                    props: { filePath: '/foo.guml', cursorLine: 12 },
+                },
+                // Second tab so popout doesn't leave an empty tabs root.
+                { slotId: 'other', viewId: 'other:view', label: 'Other' },
+            ],
+            activeTab: 0,
+        }));
+        switchToApp();
+        bindFloatStore(layoutStore.floats, () => ({ w: 1024, h: 768 }));
+        const floatId = popoutView('with-props');
+        expect(floatId).not.toBeNull();
+        const { root } = inspectActiveLayout();
+        const floatEntry = root.floats.find((f) => f.id === floatId);
+        expect(floatEntry).toBeDefined();
+        if (!floatEntry || floatEntry.content.type !== 'tabs')
+            throw new Error('expected tabs content');
+        expect((_a = floatEntry.content.tabs[0]) === null || _a === void 0 ? void 0 : _a.props).toEqual({ filePath: '/foo.guml', cursorLine: 12 });
+    });
+    it('dockFloat preserves tab.props on the docked-back entry', async () => {
+        const { popoutView, dockFloat } = await import('./inspection');
+        attachApp(makeApp({
+            type: 'tabs',
+            tabs: [
+                {
+                    slotId: 'with-props',
+                    viewId: 'editor:view',
+                    label: 'My File',
+                    props: { filePath: '/foo.guml', cursorLine: 12 },
+                },
+                // Second tab so the docked tree never becomes degenerate.
+                { slotId: 'other', viewId: 'other:view', label: 'Other' },
+            ],
+            activeTab: 0,
+        }));
+        switchToApp();
+        bindFloatStore(layoutStore.floats, () => ({ w: 1024, h: 768 }));
+        const floatId = popoutView('with-props');
+        expect(floatId).not.toBeNull();
+        const ok = dockFloat(floatId);
+        expect(ok).toBe(true);
+        const { root } = inspectActiveLayout();
+        function findTab(node) {
+            if (node.type === 'tabs')
+                return node.tabs.find((t) => t.viewId === 'editor:view');
+            if (node.type === 'split') {
+                for (const c of node.children) {
+                    const hit = findTab(c);
+                    if (hit)
+                        return hit;
+                }
+            }
+            return undefined;
+        }
+        const restored = findTab(root.docked);
+        expect(restored).toBeDefined();
+        expect(restored === null || restored === void 0 ? void 0 : restored.props).toEqual({ filePath: '/foo.guml', cursorLine: 12 });
+    });
+});
+describe('closeTab — standalone prefix closability', () => {
+    beforeEach(() => {
+        __resetLayoutStoreForTest();
+        __resetFloatManagerForTest();
+        resetSlotHostPool();
+        __resetViewRegistryForTest();
+    });
+    it('removes a standalone-prefixed tab even when the view handle declares no closable flag', async () => {
+        const slotId = 'standalone:myview:1234';
+        layoutStore.tree.docked = {
+            type: 'tabs',
+            tabs: [{ slotId, viewId: 'myview', label: 'My View' }],
+            activeTab: 0,
+        };
+        // Factory returns a handle with no closable property — simulates a shard
+        // that does not explicitly mark its view as closable.
+        registerView('myview', { mount: () => ({ unmount: () => { } }) });
+        acquireSlotHost(slotId, 'myview', 'My View');
+        // Let the deferred mount microtask run (sets closableState via standalone: prefix).
+        await Promise.resolve();
+        await Promise.resolve();
+        const removed = await closeTab(slotId);
+        expect(removed).toBe(true);
+        const root = layoutStore.root;
+        if (!root || root.type !== 'tabs')
+            throw new Error('expected tabs root');
+        expect(root.tabs.map((t) => t.slotId)).not.toContain(slotId);
+    });
+});

package/dist/layout/slotHostPool.svelte.d.ts

@@ -1,11 +1,12 @@
 import type { ViewHandle } from '../shards/types';
+import type { JsonValue } from './types';
 /**
  * Acquire (or create) the pooled host for a slot. The caller is
  * expected to `appendChild` the returned host into its own wrapper —
  * the pool does not know which wrapper owns the host at any given time,
  * and that is intentional. The same host may be passed around.
  */
-export declare function acquireSlotHost(slotId: string, viewId: string | null, label: string, meta?: Record<string, unknown>): HTMLDivElement;
+export declare function acquireSlotHost(slotId: string, viewId: string | null, label: string, meta?: Record<string, unknown>, props?: Record<string, JsonValue>): HTMLDivElement;
 /**
  * Release the pooled host. If this was the last reference, a
  * destruction is queued to run in a microtask; a later acquire before

package/dist/layout/slotHostPool.svelte.js

@@ -60,6 +60,7 @@ function onViewRegistered(viewId, factory) {
             viewId,
             label: entry.label,
             meta: entry.meta,
+            props: entry.props,
             setDirty(dirty) {
                 dirtyState[slotId] = dirty;
             },
@@ -132,7 +133,7 @@ const closableState = $state({});
  * is destroyed before its deferred mount ever runs (e.g. rapid
  * add-then-remove of a slot during a drag).
  */
-function createHost(slotId, viewId, label, meta) {
+function createHost(slotId, viewId, label, meta, props) {
     const host = document.createElement('div');
     host.className = 'slot-host';
     host.dataset.slotId = slotId;
@@ -155,6 +156,7 @@ function createHost(slotId, viewId, label, meta) {
         viewId,
         label,
         meta,
+        props,
         refcount: 0,
         resizeObserver: undefined,
         cancelPendingMount: () => {
@@ -171,6 +173,7 @@ function createHost(slotId, viewId, label, meta) {
             viewId: viewId !== null && viewId !== void 0 ? viewId : '',
             label,
             meta,
+            props,
             setDirty(dirty) {
                 dirtyState[slotId] = dirty;
             },
@@ -206,13 +209,13 @@ function createHost(slotId, viewId, label, meta) {
  * the pool does not know which wrapper owns the host at any given time,
  * and that is intentional. The same host may be passed around.
  */
-export function acquireSlotHost(slotId, viewId, label, meta) {
+export function acquireSlotHost(slotId, viewId, label, meta, props) {
     // If the slot was about to be destroyed, cancel — this acquire is the
     // "other half" of a re-parent (teardown was the previous container).
     pendingDestroy.delete(slotId);
     let entry = pool.get(slotId);
     if (!entry) {
-        entry = createHost(slotId, viewId, label, meta);
+        entry = createHost(slotId, viewId, label, meta, props);
         pool.set(slotId, entry);
     }
     else if (entry.viewId !== viewId) {

package/dist/layout/slotHostPool.test.js

@@ -116,6 +116,23 @@ describe('slotHostPool — D.6 data-sh3-view attribute', () => {
         releaseSlotHost('slot-2');
     });
 });
+// ─── D.8 ─────────────────────────────────────────────────────────────────────
+describe('slotHostPool — D.8 props threaded to MountContext', () => {
+    beforeEach(resetFramework);
+    it('threads props from acquireSlotHost into MountContext', async () => {
+        var _a;
+        const captured = [];
+        registerView('props-view', {
+            mount(_container, ctx) {
+                captured.push(ctx);
+                return { unmount() { } };
+            },
+        });
+        acquireSlotHost('p-slot', 'props-view', 'Props View', undefined, { filePath: '/a.guml' });
+        await new Promise(resolve => queueMicrotask(resolve));
+        expect((_a = captured[0]) === null || _a === void 0 ? void 0 : _a.props).toEqual({ filePath: '/a.guml' });
+    });
+});
 // ─── D.7 ─────────────────────────────────────────────────────────────────────
 describe('slotHostPool — D.7 data-sh3-scope attribute', () => {
     beforeEach(resetFramework);

package/dist/layout/store.projectScope.test.d.ts

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

package/dist/layout/store.projectScope.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { resetFramework } from '../__test__/reset';
+import { makeApp, makeAppManifest, makeSlotNode, makeTree } from '../__test__/fixtures';
+import { attachApp, detachApp, getActiveAppTree } from './store.svelte';
+import { __setActiveScope } from '../documents/config';
+import { peekZone, clearZone, backends } from '../state/zones.svelte';
+describe('getActiveAppTree', () => {
+    beforeEach(resetFramework);
+    it('returns null when no app is attached', () => {
+        expect(getActiveAppTree()).toBeNull();
+    });
+    it('returns the current tree when an app is attached', () => {
+        const app = makeApp({
+            manifest: makeAppManifest({ id: 'scope-test-app' }),
+            initialLayout: [{ name: 'default', tree: makeTree(makeSlotNode('slot-1', 'v:a')) }],
+        });
+        attachApp(app);
+        const tree = getActiveAppTree();
+        expect(tree).not.toBeNull();
+        expect(tree === null || tree === void 0 ? void 0 : tree.docked).toBeDefined();
+        detachApp();
+    });
+});
+describe('layout blob — per-scope isolation', () => {
+    // Clean up both scope blobs so a previous run can't bleed in.
+    function cleanup() {
+        clearZone('workspace', '__sh3core__:app:scope-iso-app:scope-A');
+        clearZone('workspace', '__sh3core__:app:scope-iso-app:scope-B');
+        __setActiveScope('local');
+    }
+    beforeEach(() => {
+        resetFramework();
+        cleanup();
+    });
+    afterEach(cleanup);
+    it('reads the scope-A blob when attaching with scope A, ignoring the scope-B blob', async () => {
+        // Seed both scope-keyed blobs directly with distinguishable activePresets.
+        const blobA = {
+            layoutVersion: 1,
+            activePreset: 'alt',
+            presets: {
+                default: { default: makeTree(makeSlotNode('slot-1', 'v:a')) },
+                alt: { default: makeTree(makeSlotNode('slot-2', 'v:b')) },
+            },
+        };
+        const blobB = {
+            layoutVersion: 1,
+            activePreset: 'default',
+            presets: {
+                default: { default: makeTree(makeSlotNode('slot-1', 'v:a')) },
+                alt: { default: makeTree(makeSlotNode('slot-2', 'v:b')) },
+            },
+        };
+        backends.workspace.write('__sh3core__:app:scope-iso-app:scope-A', blobA);
+        backends.workspace.write('__sh3core__:app:scope-iso-app:scope-B', blobB);
+        const app = makeApp({
+            manifest: makeAppManifest({ id: 'scope-iso-app', layoutVersion: 1 }),
+            initialLayout: [
+                { name: 'default', tree: makeTree(makeSlotNode('slot-1', 'v:a')) },
+                { name: 'alt', tree: makeTree(makeSlotNode('slot-2', 'v:b')) },
+            ],
+        });
+        // Attach under scope A — must load scope-A's blob (activePreset='alt').
+        __setActiveScope('scope-A');
+        attachApp(app);
+        const loadedA = peekZone('workspace', '__sh3core__:app:scope-iso-app:scope-A');
+        expect(loadedA === null || loadedA === void 0 ? void 0 : loadedA.activePreset).toBe('alt');
+        detachApp();
+        // Switch to scope B and re-attach — must load scope-B's blob (activePreset='default').
+        __setActiveScope('scope-B');
+        attachApp(app);
+        const loadedB = peekZone('workspace', '__sh3core__:app:scope-iso-app:scope-B');
+        expect(loadedB === null || loadedB === void 0 ? void 0 : loadedB.activePreset).toBe('default');
+        detachApp();
+    });
+});

package/dist/layout/store.svelte.d.ts

@@ -59,6 +59,12 @@ export declare function switchToApp(): void;
  */
 export declare function activeLayout(): LayoutTree;
 export declare function getActiveRoot(): 'home' | 'app';
+/**
+ * Returns a snapshot of the currently-attached app's active preset tree,
+ * or null if no app is attached. Used by the layout hook machinery to
+ * collect restored slots before mounting.
+ */
+export declare function getActiveAppTree(): LayoutTree | null;
 export declare function getAttachedAppId(): string | null;
 /**
  * Preserved for callers that still read `layoutStore.root`. The `root`

package/dist/layout/store.svelte.js

@@ -35,6 +35,7 @@ import { normalizeInitialLayout, resolveActiveTree } from './presets';
 import { viewportStore } from '../viewport/store.svelte';
 import { collectTreeSlotRefs } from './tree-walk';
 import { bindPresetBlob, unbindPresetBlob } from '../overlays/presets';
+import { getActiveScopeId } from '../documents/config';
 import { getRegisteredApp } from '../apps/registry.svelte';
 import { drawerStore } from './compact/drawerStore.svelte';
 // ---------- orphan cleanup of pre-phase-8 sh3 layout key ----------------
@@ -108,7 +109,7 @@ export function attachApp(app) {
     if (appEntry) {
         throw new Error(`Layout manager cannot attach app "${app.manifest.id}": app "${appEntry.appId}" is still attached`);
     }
-    const shardId = `__sh3core__:app:${app.manifest.id}`;
+    const shardId = `__sh3core__:app:${app.manifest.id}:${getActiveScopeId()}`;
     // Normalize the app's initialLayout into canonical presets.
     const canonical = normalizeInitialLayout(app.initialLayout);
     if (canonical.length === 0) {
@@ -204,8 +205,8 @@ export function acquireAppSlotHolds() {
         return; // idempotent
     const tree = currentTree(appEntry.proxy);
     const refs = collectTreeSlotRefs(tree);
-    for (const { slotId, viewId, label, meta } of refs) {
-        acquireSlotHost(slotId, viewId, label, meta);
+    for (const { slotId, viewId, label, meta, props } of refs) {
+        acquireSlotHost(slotId, viewId, label, meta, props);
         appEntry.heldSlotIds.push(slotId);
     }
 }
@@ -240,9 +241,16 @@ export function resetActivePresetToDefault() {
     const blob = appEntry.proxy;
     const targetName = blob.activePreset;
     let target = canonical.find((p) => p.name === targetName);
-    if (!target) {
+    if (!target)
         target = canonical[0];
-        blob.activePreset = target.name;
+    // Snapshot all declared variants (default + compact, etc.) as plain data.
+    // The app object lives in a $state Map (registry.svelte.ts), so
+    // target.variants entries are Svelte proxies; structuredClone cannot clone
+    // them. $state.snapshot unwraps to a plain JS object without new reactive
+    // state.
+    const freshVariants = {};
+    for (const key of Object.keys(target.variants)) {
+        freshVariants[key] = $state.snapshot(target.variants[key]);
     }
     // Release old slot holds before swapping the tree so the pool's
     // microtask sees no live refs and tears down hosts that the new
@@ -251,14 +259,26 @@ export function resetActivePresetToDefault() {
         releaseSlotHost(slotId);
     }
     appEntry.heldSlotIds = [];
-    // Deep-clone so the canonical object isn't aliased with future
-    // attaches or with the app's source `LayoutPreset` objects.
-    const freshTree = structuredClone(target.variants.default);
-    blob.presets[blob.activePreset].default = freshTree;
-    // Re-acquire holds against the new tree (mirrors acquireAppSlotHolds).
-    const refs = collectTreeSlotRefs(freshTree);
-    for (const { slotId, viewId, label, meta } of refs) {
-        acquireSlotHost(slotId, viewId, label, meta);
+    // Write fresh variants into the blob. If the canonical preset name differs
+    // from the stored activePreset (e.g. user migrated from the unnamed
+    // 'default' to an explicit preset name via the variant API), or the preset
+    // entry is missing entirely, add it first so the activeTree derived never
+    // reads a missing-preset state when activePreset is updated.
+    if (target.name !== targetName || !blob.presets[target.name]) {
+        blob.presets[target.name] = freshVariants;
+        blob.activePreset = target.name;
+    }
+    else {
+        // Same preset — overwrite each declared variant in place so reactive
+        // subscribers see the mutation. Resets compact variant too if declared.
+        for (const key of Object.keys(freshVariants)) {
+            blob.presets[blob.activePreset][key] = freshVariants[key];
+        }
+    }
+    // Re-acquire holds against the new default tree (mirrors acquireAppSlotHolds).
+    const refs = collectTreeSlotRefs(freshVariants.default);
+    for (const { slotId, viewId, label, meta, props } of refs) {
+        acquireSlotHost(slotId, viewId, label, meta, props);
         appEntry.heldSlotIds.push(slotId);
     }
 }
@@ -341,6 +361,16 @@ export function activeLayout() {
 export function getActiveRoot() {
     return activeRoot;
 }
+/**
+ * Returns a snapshot of the currently-attached app's active preset tree,
+ * or null if no app is attached. Used by the layout hook machinery to
+ * collect restored slots before mounting.
+ */
+export function getActiveAppTree() {
+    if (!appEntry)
+        return null;
+    return currentTree(appEntry.proxy);
+}
 export function getAttachedAppId() {
     var _a;
     return (_a = appEntry === null || appEntry === void 0 ? void 0 : appEntry.appId) !== null && _a !== void 0 ? _a : null;

package/dist/layout/tree-walk.d.ts

@@ -1,4 +1,4 @@
-import type { LayoutNode, LayoutTree } from './types';
+import type { LayoutNode, LayoutTree, RestoredSlot, JsonValue } from './types';
 /**
  * Collect the slot id / view id pairs of every slot leaf (including the
  * slots embedded inside tabs entries) in a layout tree. Used by the
@@ -13,6 +13,7 @@ export declare function collectSlotRefs(tree: LayoutNode): {
     viewId: string | null;
     label: string;
     meta?: Record<string, unknown>;
+    props?: Record<string, JsonValue>;
 }[];
 /**
  * Multi-root version of `collectSlotRefs`: walks the docked tree first
@@ -25,4 +26,10 @@ export declare function collectTreeSlotRefs(tree: LayoutTree): {
     viewId: string | null;
     label: string;
     meta?: Record<string, unknown>;
+    props?: Record<string, JsonValue>;
 }[];
+/**
+ * Collect every slot that has a non-null viewId, for use by shard layout
+ * hooks (`onLayoutWillRestore`, `onLayoutRestored`). Excludes empty slots.
+ */
+export declare function collectRestoredSlots(tree: LayoutTree): RestoredSlot[];

package/dist/layout/tree-walk.js

@@ -20,12 +20,13 @@ export function collectSlotRefs(tree) {
                 viewId: node.viewId,
                 label: node.viewId || node.slotId,
                 meta: node.meta,
+                props: node.props,
             });
             return;
         }
         if (node.type === 'tabs') {
             for (const t of node.tabs) {
-                out.push({ slotId: t.slotId, viewId: t.viewId, label: t.label, meta: t.meta });
+                out.push({ slotId: t.slotId, viewId: t.viewId, label: t.label, meta: t.meta, props: t.props });
             }
             return;
         }
@@ -49,3 +50,12 @@ export function collectTreeSlotRefs(tree) {
     }
     return out;
 }
+/**
+ * Collect every slot that has a non-null viewId, for use by shard layout
+ * hooks (`onLayoutWillRestore`, `onLayoutRestored`). Excludes empty slots.
+ */
+export function collectRestoredSlots(tree) {
+    return collectTreeSlotRefs(tree)
+        .filter((r) => r.viewId !== null)
+        .map(({ slotId, viewId, props }) => ({ slotId, viewId, props }));
+}