sh3-core 0.19.1 → 0.19.5

package/dist/layout/floats.d.ts

@@ -23,6 +23,33 @@ export declare function cascadePosition(existing: FloatEntry[], bounds: {
 };
 /** Stable, process-unique float id. Not cryptographic — just unique within a session. */
 export declare function generateFloatId(): string;
+/**
+ * Pull a float's rect into the supplied viewport bounds. Used at bind
+ * time so a float persisted from a larger viewport doesn't render past
+ * the overlay root — Firefox in particular grows the parent's painted
+ * area to fit an off-screen abspos child, which visibly bleeds the
+ * docked grid (footer ends up below the viewport).
+ *
+ * Size is shrunk to fit but never below `minSize`; if `minSize` itself
+ * exceeds bounds, position is pinned to (0,0) and size stays at min.
+ * Position is then clamped so the frame fits within bounds.
+ */
+export declare function clampFloatToViewport(rect: {
+    position: {
+        x: number;
+        y: number;
+    };
+    size: Size;
+}, minSize: Size, bounds: {
+    w: number;
+    h: number;
+}): {
+    position: {
+        x: number;
+        y: number;
+    };
+    size: Size;
+};
 /**
  * True if a LayoutNode subtree contains no leaf slot with a bound viewId.
  * Used by the drag-commit auto-close invariant: when the last bound leaf

package/dist/layout/floats.js

@@ -55,6 +55,26 @@ export function generateFloatId() {
     floatIdCounter += 1;
     return `float-${Date.now().toString(36)}-${floatIdCounter.toString(36)}`;
 }
+/**
+ * Pull a float's rect into the supplied viewport bounds. Used at bind
+ * time so a float persisted from a larger viewport doesn't render past
+ * the overlay root — Firefox in particular grows the parent's painted
+ * area to fit an off-screen abspos child, which visibly bleeds the
+ * docked grid (footer ends up below the viewport).
+ *
+ * Size is shrunk to fit but never below `minSize`; if `minSize` itself
+ * exceeds bounds, position is pinned to (0,0) and size stays at min.
+ * Position is then clamped so the frame fits within bounds.
+ */
+export function clampFloatToViewport(rect, minSize, bounds) {
+    const w = Math.max(minSize.w, Math.min(rect.size.w, bounds.w));
+    const h = Math.max(minSize.h, Math.min(rect.size.h, bounds.h));
+    const maxX = Math.max(0, bounds.w - w);
+    const maxY = Math.max(0, bounds.h - h);
+    const x = Math.max(0, Math.min(rect.position.x, maxX));
+    const y = Math.max(0, Math.min(rect.position.y, maxY));
+    return { position: { x, y }, size: { w, h } };
+}
 /**
  * True if a LayoutNode subtree contains no leaf slot with a bound viewId.
  * Used by the drag-commit auto-close invariant: when the last bound leaf

package/dist/layout/floats.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { computeMinSize, cascadePosition, isEmptyContent } from './floats';
+import { computeMinSize, cascadePosition, isEmptyContent, clampFloatToViewport } from './floats';
 const slot = (slotId, viewId = 'v') => ({
     type: 'slot',
     slotId,
@@ -72,6 +72,39 @@ describe('cascadePosition', () => {
         expect(cascadePosition(existing, bounds)).toEqual({ x: 48, y: 48 });
     });
 });
+describe('clampFloatToViewport', () => {
+    const min = { w: 120, h: 80 };
+    const bounds = { w: 1024, h: 768 };
+    it('returns the rect unchanged when fully inside bounds', () => {
+        const out = clampFloatToViewport({ position: { x: 100, y: 200 }, size: { w: 600, h: 400 } }, min, bounds);
+        expect(out).toEqual({ position: { x: 100, y: 200 }, size: { w: 600, h: 400 } });
+    });
+    it('pulls a float that extends past the right edge back inside', () => {
+        const out = clampFloatToViewport({ position: { x: 900, y: 50 }, size: { w: 600, h: 400 } }, min, bounds);
+        expect(out.position.x).toBe(bounds.w - 600);
+        expect(out.position.y).toBe(50);
+        expect(out.size).toEqual({ w: 600, h: 400 });
+    });
+    it('pulls a float that extends past the bottom edge back inside', () => {
+        const out = clampFloatToViewport({ position: { x: 50, y: 600 }, size: { w: 600, h: 400 } }, min, bounds);
+        expect(out.position.y).toBe(bounds.h - 400);
+    });
+    it('clamps negative position back to (0,0)', () => {
+        const out = clampFloatToViewport({ position: { x: -200, y: -50 }, size: { w: 600, h: 400 } }, min, bounds);
+        expect(out.position).toEqual({ x: 0, y: 0 });
+    });
+    it('shrinks size larger than bounds down to bounds (above min)', () => {
+        const out = clampFloatToViewport({ position: { x: 0, y: 0 }, size: { w: 4000, h: 3000 } }, min, bounds);
+        expect(out.size).toEqual({ w: bounds.w, h: bounds.h });
+        expect(out.position).toEqual({ x: 0, y: 0 });
+    });
+    it('never shrinks size below the supplied min, even when bounds < min', () => {
+        const tiny = { w: 80, h: 60 };
+        const out = clampFloatToViewport({ position: { x: 999, y: 999 }, size: { w: 600, h: 400 } }, min, tiny);
+        expect(out.size).toEqual(min);
+        expect(out.position).toEqual({ x: 0, y: 0 });
+    });
+});
 describe('isEmptyContent', () => {
     it('true for a slot with null viewId', () => {
         expect(isEmptyContent({ type: 'slot', slotId: 's', viewId: null })).toBe(true);

package/dist/layout/inspection.d.ts

@@ -69,19 +69,30 @@ export declare function popoutView(slotId: string): string | null;
 export declare function dockFloat(floatId: string): boolean;
 /**
  * Dock a view into the currently-rendered layout without caring which
- * root it is. Used by the Ctrl+` sh3 hotkey and other "just put it
- * somewhere sensible" callers. Policy:
+ * root it is. Used by the Ctrl+` sh3 hotkey, the `open <viewId>` verb,
+ * and other "just put it somewhere sensible" callers. Policy:
  *
  *   1. If a tab with the same `viewId` already exists, focus it and
  *      return. Callers don't want a second instance of a singleton view
  *      every time they hit the shortcut.
- *   2. Otherwise, append the entry to the first tabs group found
- *      (`spliceIntoActiveLayout` semantics).
- *   3. If there's no tabs group (e.g. the home root is a single slot),
- *      split the first slot leaf horizontally and put the entry on the
- *      right. This is the "floating window" fallback described in
- *      roadmap SH9 / DF3 — when floating panels land, callers should
- *      prefer that path for ephemeral docks.
+ *   2. Prefer a tabs group whose entries are explicitly flagged
+ *      `role: 'body'` — that's the canonical "main content" target when
+ *      authors marked it. This step matches user intent better than
+ *      "first tabs group found" in layouts that pair a sidebar tabs
+ *      group with a body tabs group.
+ *   3. Otherwise, prefer a standalone slot explicitly flagged
+ *      `role: 'body'` — split it horizontally and place the new entry
+ *      on the right (same shape as the generic slot fallback below).
+ *   4. Otherwise, append to the first tabs group found.
+ *   5. Otherwise, split the first slot leaf horizontally. This is the
+ *      "floating window" fallback described in roadmap SH9 / DF3.
+ *
+ * Steps 2-3 use a *strict* role check (`=== 'body'`, not resolveRole).
+ * An unmarked slot defaults to body via resolveRole, but treating every
+ * unmarked slot as a body anchor would make step 3 swallow every
+ * standalone slot in the tree before step 4 ever got a chance — which
+ * inverts the documented fallback order. Only explicit body markers
+ * promote a node above the generic fallback.
  *
  * Returns true if the view was focused or inserted, false if the layout
  * was empty or otherwise un-dockable.

package/dist/layout/inspection.js

@@ -16,6 +16,24 @@ import { activeLayout, getActiveRoot } from './store.svelte';
 import { nodeAtPath, findTabBySlotId, removeTabBySlotId, cleanupTree, splitNodeAtPath, locateSlotIn, } from './ops';
 import { getSlotHandle } from './slotHostPool.svelte';
 import { floatManager } from '../overlays/float';
+import { viewportStore } from '../viewport/store.svelte';
+import { compactRootStore } from './compact/rootStore.svelte';
+/**
+ * In compact mode the user sees one root at a time. When focus lands on
+ * a slot in a float, swap the compact body root to that float before
+ * returning. When focus lands in the docked tree, snap back to docked.
+ * Desktop is unaffected.
+ */
+function maybeSwapForCompact(located) {
+    if (viewportStore.current.class !== 'compact')
+        return;
+    if (located.kind === 'float') {
+        compactRootStore.setRoot({ kind: 'float', floatId: located.floatId });
+    }
+    else {
+        compactRootStore.reset();
+    }
+}
 /**
  * Read-only snapshot of the currently-rendered layout tree. The return
  * value is the live object — callers MUST NOT mutate it directly;
@@ -48,8 +66,10 @@ export function spliceIntoActiveLayout(entry) {
  */
 export function focusTab(slotId) {
     const tree = activeLayout();
-    if (focusTabWhere(tree.docked, (entry) => entry.slotId === slotId))
+    if (focusTabWhere(tree.docked, (entry) => entry.slotId === slotId)) {
+        maybeSwapForCompact({ kind: 'docked' });
         return true;
+    }
     return focusTabInFloats(tree, (entry) => entry.slotId === slotId);
 }
 /**
@@ -58,8 +78,10 @@ export function focusTab(slotId) {
  */
 export function focusView(viewId) {
     const tree = activeLayout();
-    if (focusTabWhere(tree.docked, (entry) => entry.viewId === viewId))
+    if (focusTabWhere(tree.docked, (entry) => entry.viewId === viewId)) {
+        maybeSwapForCompact({ kind: 'docked' });
         return true;
+    }
     return focusTabInFloats(tree, (entry) => entry.viewId === viewId);
 }
 /** Walk the tree looking for a tab entry that satisfies `pred`, activate it. */
@@ -85,6 +107,7 @@ function focusTabInFloats(tree, pred) {
     for (const floatEntry of tree.floats) {
         if (focusTabWhere(floatEntry.content, pred)) {
             floatManager.focus(floatEntry.id);
+            maybeSwapForCompact({ kind: 'float', floatId: floatEntry.id });
             return true;
         }
     }
@@ -274,19 +297,30 @@ function findFirstSlotPath(node, path = []) {
 }
 /**
  * Dock a view into the currently-rendered layout without caring which
- * root it is. Used by the Ctrl+` sh3 hotkey and other "just put it
- * somewhere sensible" callers. Policy:
+ * root it is. Used by the Ctrl+` sh3 hotkey, the `open <viewId>` verb,
+ * and other "just put it somewhere sensible" callers. Policy:
  *
  *   1. If a tab with the same `viewId` already exists, focus it and
  *      return. Callers don't want a second instance of a singleton view
  *      every time they hit the shortcut.
- *   2. Otherwise, append the entry to the first tabs group found
- *      (`spliceIntoActiveLayout` semantics).
- *   3. If there's no tabs group (e.g. the home root is a single slot),
- *      split the first slot leaf horizontally and put the entry on the
- *      right. This is the "floating window" fallback described in
- *      roadmap SH9 / DF3 — when floating panels land, callers should
- *      prefer that path for ephemeral docks.
+ *   2. Prefer a tabs group whose entries are explicitly flagged
+ *      `role: 'body'` — that's the canonical "main content" target when
+ *      authors marked it. This step matches user intent better than
+ *      "first tabs group found" in layouts that pair a sidebar tabs
+ *      group with a body tabs group.
+ *   3. Otherwise, prefer a standalone slot explicitly flagged
+ *      `role: 'body'` — split it horizontally and place the new entry
+ *      on the right (same shape as the generic slot fallback below).
+ *   4. Otherwise, append to the first tabs group found.
+ *   5. Otherwise, split the first slot leaf horizontally. This is the
+ *      "floating window" fallback described in roadmap SH9 / DF3.
+ *
+ * Steps 2-3 use a *strict* role check (`=== 'body'`, not resolveRole).
+ * An unmarked slot defaults to body via resolveRole, but treating every
+ * unmarked slot as a body anchor would make step 3 swallow every
+ * standalone slot in the tree before step 4 ever got a chance — which
+ * inverts the documented fallback order. Only explicit body markers
+ * promote a node above the generic fallback.
  *
  * Returns true if the view was focused or inserted, false if the layout
  * was empty or otherwise un-dockable.
@@ -297,20 +331,64 @@ export function dockIntoActiveLayout(entry) {
     // 1. Already present? Focus it.
     if (focusView((_a = entry.viewId) !== null && _a !== void 0 ? _a : ''))
         return true;
-    // 2. Existing tabs group wins.
+    // 2. A tabs group explicitly carrying body content wins.
+    const bodyTabs = findBodyTabsNode(root);
+    if (bodyTabs) {
+        bodyTabs.tabs.push(entry);
+        bodyTabs.activeTab = bodyTabs.tabs.length - 1;
+        return true;
+    }
+    // 3. A standalone slot explicitly marked as body is next.
+    const bodySlotPath = findBodySlotPath(root);
+    if (bodySlotPath) {
+        splitNodeAtPath(root, bodySlotPath, entry, 'right');
+        return true;
+    }
+    // 4. Existing tabs group wins (generic fallback).
     const tabs = findFirstTabsNode(root);
     if (tabs) {
         tabs.tabs.push(entry);
         tabs.activeTab = tabs.tabs.length - 1;
         return true;
     }
-    // 3. Fallback: split the first valid slot leaf.
+    // 5. Fallback: split the first valid slot leaf.
     const slotPath = findFirstSlotPath(root);
     if (!slotPath)
         return false;
     splitNodeAtPath(root, slotPath, entry, 'right');
     return true;
 }
+/**
+ * Find a tabs group explicitly flagged `role: 'body'`. Strict —
+ * defaulted body roles don't count, see the dockIntoActiveLayout
+ * docblock for why.
+ */
+function findBodyTabsNode(node) {
+    if (node.type === 'tabs') {
+        return node.role === 'body' ? node : null;
+    }
+    if (node.type === 'split') {
+        for (const c of node.children) {
+            const hit = findBodyTabsNode(c);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+/** Path to the first slot leaf explicitly flagged `role: 'body'`. */
+function findBodySlotPath(node, path = []) {
+    if (node.type === 'slot')
+        return node.role === 'body' ? path : null;
+    if (node.type === 'split') {
+        for (let i = 0; i < node.children.length; i++) {
+            const hit = findBodySlotPath(node.children[i], [...path, i]);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
 /**
  * Find which root a slot currently lives under in the active layout.
  * Returns `{ kind: 'docked' }` when the slot is anywhere in the docked

package/dist/layout/inspection.svelte.test.d.ts

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

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

@@ -0,0 +1,163 @@
+/*
+ * dockIntoActiveLayout policy tests — verify the body-role preference
+ * lands before generic fallbacks. The `open <viewId>` verb routes
+ * through this function; getting the policy wrong means views land in
+ * sidebar tabs groups instead of body ones in apps that mark both.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { flushSync } from 'svelte';
+import { attachApp, switchToApp, __resetLayoutStoreForTest, layoutStore, } from './store.svelte';
+import { dockIntoActiveLayout } from './inspection';
+let appCounter = 0;
+function makeApp(initialLayout) {
+    // Unique id per call so workspace-zone storage from one test doesn't
+    // adapt-and-override another test's initialLayout via attachApp's
+    // version-gate path.
+    return {
+        manifest: { id: `test-app-${++appCounter}`, layoutVersion: 1 },
+        initialLayout,
+    };
+}
+function nextEntry(viewId) {
+    return { slotId: `s:${viewId}:${Math.random()}`, viewId, label: viewId };
+}
+describe('dockIntoActiveLayout — body-role preference', () => {
+    beforeEach(() => {
+        __resetLayoutStoreForTest();
+    });
+    it('appends into a tabs group flagged as body when one exists alongside a non-body tabs group', () => {
+        attachApp(makeApp({
+            type: 'split', direction: 'horizontal', sizes: [0.3, 0.7],
+            children: [
+                {
+                    type: 'tabs',
+                    role: 'sidebar',
+                    tabs: [{ slotId: 'sb-1', viewId: 'sb:explorer', label: 'Explorer' }],
+                    activeTab: 0,
+                },
+                {
+                    type: 'tabs',
+                    role: 'body',
+                    tabs: [{ slotId: 'b-1', viewId: 'body:editor', label: 'Editor' }],
+                    activeTab: 0,
+                },
+            ],
+        }));
+        switchToApp();
+        flushSync();
+        expect(dockIntoActiveLayout(nextEntry('body:newdoc'))).toBe(true);
+        const root = layoutStore.root;
+        const sidebar = root.children[0];
+        const body = root.children[1];
+        expect(sidebar.tabs.map((t) => t.viewId)).toEqual(['sb:explorer']);
+        expect(body.tabs.map((t) => t.viewId)).toEqual(['body:editor', 'body:newdoc']);
+        expect(body.activeTab).toBe(1);
+    });
+    it('splits a standalone slot flagged as body when no body tabs group exists', () => {
+        attachApp(makeApp({
+            type: 'split', direction: 'horizontal', sizes: [0.3, 0.7],
+            children: [
+                { type: 'slot', slotId: 'sb', viewId: 'sb:explorer', role: 'sidebar' },
+                { type: 'slot', slotId: 'main', viewId: 'body:editor', role: 'body' },
+            ],
+        }));
+        switchToApp();
+        flushSync();
+        expect(dockIntoActiveLayout(nextEntry('body:newdoc'))).toBe(true);
+        const root = layoutStore.root;
+        // The body slot got split — its position in the parent is now a split node.
+        const right = root.children[1];
+        expect(right.type).toBe('split');
+    });
+    it('falls back to the first tabs group when no body-flagged target exists', () => {
+        attachApp(makeApp({
+            type: 'tabs',
+            tabs: [{ slotId: 'a', viewId: 'view:a', label: 'A' }],
+            activeTab: 0,
+        }));
+        switchToApp();
+        flushSync();
+        expect(dockIntoActiveLayout(nextEntry('view:b'))).toBe(true);
+        const root = layoutStore.root;
+        expect(root.tabs.map((t) => t.viewId)).toEqual(['view:a', 'view:b']);
+        expect(root.activeTab).toBe(1);
+    });
+    it('does NOT prefer a tabs group whose entries are only defaulted-to-body (strict role check)', () => {
+        // The "first tabs group" already wins the generic fallback in this
+        // shape — the assertion here is that body-preference doesn't kick in
+        // (which it would if we used resolveRole and treated unset as body)
+        // and accidentally promote a sibling tabs group above the first one.
+        attachApp(makeApp({
+            type: 'split', direction: 'horizontal', sizes: [0.5, 0.5],
+            children: [
+                {
+                    type: 'tabs',
+                    tabs: [{ slotId: 'l', viewId: 'view:l', label: 'L' }], // role unset
+                    activeTab: 0,
+                },
+                {
+                    type: 'tabs',
+                    tabs: [{ slotId: 'r', viewId: 'view:r', label: 'R' }], // role unset
+                    activeTab: 0,
+                },
+            ],
+        }));
+        switchToApp();
+        flushSync();
+        expect(dockIntoActiveLayout(nextEntry('view:new'))).toBe(true);
+        const root = layoutStore.root;
+        const left = root.children[0];
+        const right = root.children[1];
+        expect(left.tabs.map((t) => t.viewId)).toEqual(['view:l', 'view:new']);
+        expect(right.tabs.map((t) => t.viewId)).toEqual(['view:r']);
+    });
+});
+// ---------------------------------------------------------------------------
+// Compact body-root swap on focusView / focusTab
+// ---------------------------------------------------------------------------
+import { compactRootStore, __resetCompactRootStoreForTest, } from './compact/rootStore.svelte';
+import { viewportStore } from '../viewport/store.svelte';
+import { focusView } from './inspection';
+import { floatManager, __resetFloatManagerForTest, bindFloatStore, } from '../overlays/float';
+describe('focusView — compact body-root swap', () => {
+    beforeEach(() => {
+        __resetLayoutStoreForTest();
+        __resetCompactRootStoreForTest();
+        __resetFloatManagerForTest();
+        viewportStore.override(null);
+        bindFloatStore(layoutStore.floats, () => ({ w: 1024, h: 768 }));
+    });
+    it('compact: focusView in a float swaps body root before activating', () => {
+        viewportStore.override('compact');
+        const id = floatManager.open('view:in-float', { title: 'In Float' });
+        // open() in compact already auto-switches; reset so we can see the swap.
+        compactRootStore.reset();
+        expect(compactRootStore.current).toEqual({ kind: 'docked' });
+        const ok = focusView('view:in-float');
+        expect(ok).toBe(true);
+        expect(compactRootStore.current).toEqual({ kind: 'float', floatId: id });
+        viewportStore.override(null);
+    });
+    it('compact: focusView for a docked tab resets body root', () => {
+        viewportStore.override('compact');
+        layoutStore.tree.docked = {
+            type: 'tabs',
+            tabs: [{ slotId: 's-d', viewId: 'view:docked', label: 'Docked' }],
+            activeTab: 0,
+        };
+        floatManager.open('view:other');
+        expect(compactRootStore.current.kind).toBe('float');
+        const ok = focusView('view:docked');
+        expect(ok).toBe(true);
+        expect(compactRootStore.current).toEqual({ kind: 'docked' });
+        viewportStore.override(null);
+    });
+    it('desktop: focusView does not touch the compact body root', () => {
+        viewportStore.override('desktop');
+        floatManager.open('view:any');
+        const before = compactRootStore.current;
+        focusView('view:any');
+        expect(compactRootStore.current).toEqual(before);
+        viewportStore.override(null);
+    });
+});

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

@@ -29,7 +29,7 @@ describe('layout schema v4 → v5 backward compatibility', () => {
         expect(slotA.role).toBeUndefined();
         expect(v4Blob.drawers).toBeUndefined();
     });
-    it('LAYOUT_SCHEMA_VERSION is 6', () => {
-        expect(LAYOUT_SCHEMA_VERSION).toBe(6);
+    it('LAYOUT_SCHEMA_VERSION is 7', () => {
+        expect(LAYOUT_SCHEMA_VERSION).toBe(7);
     });
 });

package/dist/layout/types.d.ts

@@ -5,8 +5,9 @@ export type SplitDirection = 'horizontal' | 'vertical';
  * viewports to derive a compact rendering (sidebars/inspectors lift into
  * drawer surfaces, body slots fill the page).
  *
- * Default `'body'`. Authored on a slot or tab entry; if unset, falls back
- * to the view's `defaultRole` (registered via the shard contract). See
+ * Default `'body'`. Authored on a slot node or a tabs node (one role
+ * per tabs group, applied to every tab); if unset, falls back to the
+ * view's `defaultRole` (registered via the shard contract). See
  * `layout/compact/resolveRole.ts`.
  */
 export type SlotRole = 'body' | 'sidebar' | 'inspector';
@@ -56,11 +57,6 @@ export interface TabEntry {
     label: string;
     /** Optional icon hint (not yet rendered in phase 8). */
     icon?: string;
-    /**
-     * Slot-role hint for compact rendering. Default `'body'` via
-     * `resolveRole(slot, viewDefault)`. Inert on desktop.
-     */
-    role?: SlotRole;
     /**
      * Caller-supplied instance data, threaded to `MountContext.meta`.
      * Ephemeral — not serialized with the layout tree.
@@ -97,6 +93,13 @@ export interface TabsNode {
      * Inert when not rendered as a carousel.
      */
     wrap?: boolean;
+    /**
+     * Role hint for the whole tab group in compact rendering. Default
+     * `'body'` via `resolveRole(node, viewDefault)`. Inert on desktop.
+     * Applies to every tab in the group — mixed-role tab groups are not
+     * representable by design.
+     */
+    role?: SlotRole;
 }
 /**
  * A leaf layout node that holds a single mounted view. `slotId` is the stable
@@ -215,7 +218,7 @@ export type TreeRootRef = {
  * the default tree takes over — phase 7 deliberately does not ship a
  * migration framework, only the hook for one.
  */
-export declare const LAYOUT_SCHEMA_VERSION = 6;
+export declare const LAYOUT_SCHEMA_VERSION = 7;
 /**
  * The wire shape of a persisted layout in the workspace state zone.
  * One blob per sh3 (or per program, once per-program layouts exist);

package/dist/layout/types.js

@@ -22,4 +22,4 @@
  * the default tree takes over — phase 7 deliberately does not ship a
  * migration framework, only the hook for one.
  */
-export const LAYOUT_SCHEMA_VERSION = 6;
+export const LAYOUT_SCHEMA_VERSION = 7;

package/dist/layout/types.test.js

@@ -20,7 +20,7 @@ describe('TabsNode.wrap', () => {
     });
 });
 describe('LAYOUT_SCHEMA_VERSION', () => {
-    it('is 6 (bumped for TabsNode.wrap)', () => {
-        expect(LAYOUT_SCHEMA_VERSION).toBe(6);
+    it('is 7 (bumped: role moved from TabEntry to TabsNode)', () => {
+        expect(LAYOUT_SCHEMA_VERSION).toBe(7);
     });
 });