sh3-core 0.19.0 → 0.19.3

package/dist/layout/compact/derive.test.js

@@ -128,26 +128,26 @@ describe('derive', () => {
     describe('tabs nodes', () => {
         it('tabs of body slots stay in body root', () => {
             const tree = {
-                type: 'tabs', activeTab: 0,
+                type: 'tabs', activeTab: 0, role: 'body',
                 tabs: [
-                    { slotId: 't1', viewId: 'v:t1', label: 'Tab 1', role: 'body' },
-                    { slotId: 't2', viewId: 'v:t2', label: 'Tab 2', role: 'body' },
+                    { slotId: 't1', viewId: 'v:t1', label: 'Tab 1' },
+                    { slotId: 't2', viewId: 'v:t2', label: 'Tab 2' },
                 ],
             };
             const result = derive(tree);
             expect(result.bodyRoot.type).toBe('tabs');
         });
-        it('tabs with mixed roles split body tabs from sidebar slots', () => {
+        it('body tabs node alongside sidebar slot stays in body root', () => {
             var _a;
             const tree = {
                 type: 'split', direction: 'horizontal', sizes: [0.2, 0.8],
                 children: [
                     { type: 'slot', slotId: 'sb', viewId: 'v:sb', role: 'sidebar' },
                     {
-                        type: 'tabs', activeTab: 0,
+                        type: 'tabs', activeTab: 0, role: 'body',
                         tabs: [
-                            { slotId: 't1', viewId: 'v:t1', label: 'Tab 1', role: 'body' },
-                            { slotId: 't2', viewId: 'v:t2', label: 'Tab 2', role: 'body' },
+                            { slotId: 't1', viewId: 'v:t1', label: 'Tab 1' },
+                            { slotId: 't2', viewId: 'v:t2', label: 'Tab 2' },
                         ],
                     },
                 ],
@@ -156,13 +156,33 @@ describe('derive', () => {
             expect(result.bodyRoot.type).toBe('tabs');
             expect((_a = result.drawers.left) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['sb']);
         });
+        it('sidebar-tagged tabs node lifts all tabs into a drawer', () => {
+            var _a;
+            const tree = {
+                type: 'split', direction: 'horizontal', sizes: [0.3, 0.7],
+                children: [
+                    {
+                        type: 'tabs', activeTab: 0, role: 'sidebar',
+                        tabs: [
+                            { slotId: 'sb-1', viewId: 'v:sb-1', label: 'Files' },
+                            { slotId: 'sb-2', viewId: 'v:sb-2', label: 'Search' },
+                        ],
+                    },
+                    { type: 'slot', slotId: 'body', viewId: 'v:body', role: 'body' },
+                ],
+            };
+            const result = derive(tree);
+            expect((_a = result.drawers.left) === null || _a === void 0 ? void 0 : _a.slots.map((s) => s.slotId)).toEqual(['sb-1', 'sb-2']);
+            expect(result.bodyRoot.slotId).toBe('body');
+        });
     });
     describe('carousels', () => {
         it('includes a carousels Map in the output', () => {
             var _a;
             const tree = {
                 type: 'tabs',
-                tabs: [{ slotId: 't0', viewId: null, label: 'Only', role: 'body' }],
+                role: 'body',
+                tabs: [{ slotId: 't0', viewId: null, label: 'Only' }],
                 activeTab: 0,
             };
             const out = derive(tree);
@@ -184,7 +204,8 @@ describe('derive', () => {
                     { type: 'slot', slotId: 'sb', viewId: null, role: 'sidebar' },
                     {
                         type: 'tabs',
-                        tabs: [{ slotId: 't0', viewId: null, label: 'Body Tab', role: 'body' }],
+                        role: 'body',
+                        tabs: [{ slotId: 't0', viewId: null, label: 'Body Tab' }],
                         activeTab: 0,
                     },
                 ],

package/dist/layout/drag.svelte.js

@@ -44,7 +44,7 @@ import { cleanupTree, insertTabIntoTabs, moveTabWithinTabs, removeTabBySlotId, s
 import { layoutStore } from './store.svelte';
 import { isEmptyContent } from './floats';
 import { claim, revoke } from '../gestures/pointerClaim';
-import { ancestorCount } from '../gestures';
+import { ancestorCount, logGesture } from '../gestures';
 export const dragState = $state({
     phase: 'idle',
     source: null,
@@ -116,6 +116,8 @@ function removeGlobalListeners() {
     delete document.body.dataset.dragging;
 }
 function onPointerMove(e) {
+    if (e.pointerId !== activeDragPointerId)
+        return;
     dragState.pointerX = e.clientX;
     dragState.pointerY = e.clientY;
     if (dragState.phase === 'pending') {
@@ -126,7 +128,9 @@ function onPointerMove(e) {
         }
     }
 }
-function onPointerUp(_e) {
+function onPointerUp(e) {
+    if (e.pointerId !== activeDragPointerId)
+        return;
     const wasDragging = dragState.phase === 'dragging';
     if (wasDragging) {
         commit();
@@ -137,7 +141,16 @@ function onPointerUp(_e) {
     }
     teardown();
 }
-function onPointerCancel(_e) {
+function onPointerCancel(e) {
+    // Filter by pointer id. Without this, any pointercancel on the window
+    // (palm contact, ghost touch, stylus cancellation while a finger drag
+    // is active) would tear down a legitimate tab drag — same touch-only
+    // auto-release class as in carousel / floatframe / splitter.
+    if (e.pointerId !== activeDragPointerId) {
+        logGesture('tabdrag:cancel-other-id', e, { activeDragPointerId });
+        return;
+    }
+    logGesture('tabdrag:cancel-our-id', e, { activeDragPointerId });
     teardown();
 }
 function rootNode(ref) {

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

@@ -274,19 +274,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 +308,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,114 @@
+/*
+ * 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']);
+    });
+});

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);
     });
 });