sh3-core 0.7.1 → 0.7.3

package/dist/Shell.svelte

@@ -20,7 +20,7 @@
   import type { OverlayLayer } from './overlays/types';
   import { registerLayerRoot, unregisterLayerRoot } from './overlays/roots';
   import { bindFloatStore, unbindFloatStore, floatManager } from './overlays/float';
-  import { returnToHome, isAdmin } from './api';
+  import { returnToHome, isAdmin, focusView } from './api';
   import { getActiveRoot, layoutStore } from './layout/store.svelte';
   import { isAuthenticated, isLocalOwner, getUser, logout } from './auth/index';
   import iconsUrl from './assets/icons.svg';
@@ -82,7 +82,8 @@
         ) return;
       }
       e.preventDefault();
-      floatManager.open('shell:terminal', { title: 'Shell' });
+      if (!focusView('shell:terminal'))
+        floatManager.open('shell:terminal', { title: 'Shell' });
     }
     window.addEventListener('keydown', onKeyDown);
     return () => window.removeEventListener('keydown', onKeyDown);

package/dist/contract.d.ts

@@ -8,12 +8,22 @@ export declare const contract: {
      *  listed in shardImports or hostImports is illegal. */
     readonly packagePrefix: "sh3-core";
     readonly shard: {
+        /** Fields external authors must declare. */
+        readonly sourceRequiredFields: readonly ["id", "label", "views"];
+        /** Fields the framework stamps at load time — must NOT appear in source. */
+        readonly runtimeRequiredFields: readonly ["version"];
+        /** Union of both — the full runtime shape. Kept for backward compat. */
         readonly requiredFields: readonly ["id", "label", "version", "views"];
         readonly views: {
             readonly requiredFields: readonly ["id", "label"];
         };
     };
     readonly app: {
+        /** Fields external authors must declare. */
+        readonly sourceRequiredFields: readonly ["id", "label", "requiredShards", "layoutVersion"];
+        /** Fields the framework stamps at load time — must NOT appear in source. */
+        readonly runtimeRequiredFields: readonly ["version"];
+        /** Union of both — the full runtime shape. Kept for backward compat. */
         readonly requiredFields: readonly ["id", "label", "version", "requiredShards", "layoutVersion"];
     };
 };

package/dist/contract.js

@@ -17,12 +17,22 @@ export const contract = {
      *  listed in shardImports or hostImports is illegal. */
     packagePrefix: 'sh3-core',
     shard: {
+        /** Fields external authors must declare. */
+        sourceRequiredFields: ['id', 'label', 'views'],
+        /** Fields the framework stamps at load time — must NOT appear in source. */
+        runtimeRequiredFields: ['version'],
+        /** Union of both — the full runtime shape. Kept for backward compat. */
         requiredFields: ['id', 'label', 'version', 'views'],
         views: {
             requiredFields: ['id', 'label'],
         },
     },
     app: {
+        /** Fields external authors must declare. */
+        sourceRequiredFields: ['id', 'label', 'requiredShards', 'layoutVersion'],
+        /** Fields the framework stamps at load time — must NOT appear in source. */
+        runtimeRequiredFields: ['version'],
+        /** Union of both — the full runtime shape. Kept for backward compat. */
         requiredFields: ['id', 'label', 'version', 'requiredShards', 'layoutVersion'],
     },
 };

package/dist/layout/inspection.js

@@ -15,6 +15,7 @@
 import { activeLayout, getActiveRoot } from './store.svelte';
 import { nodeAtPath, findTabBySlotId, removeTabBySlotId, cleanupTree, splitNodeAtPath, } from './ops';
 import { getSlotHandle } from './slotHostPool.svelte';
+import { floatManager } from '../overlays/float';
 /**
  * Read-only snapshot of the currently-rendered layout tree. The return
  * value is the live object — callers MUST NOT mutate it directly;
@@ -46,16 +47,20 @@ export function spliceIntoActiveLayout(entry) {
  * layout. Returns `true` if a matching tab was found and activated.
  */
 export function focusTab(slotId) {
-    const root = activeLayout().docked;
-    return focusTabWhere(root, (entry) => entry.slotId === slotId);
+    const tree = activeLayout();
+    if (focusTabWhere(tree.docked, (entry) => entry.slotId === slotId))
+        return true;
+    return focusTabInFloats(tree, (entry) => entry.slotId === slotId);
 }
 /**
  * Activate the first tab whose `viewId` matches in the currently-rendered
  * layout. Returns `true` if a matching tab was found and activated.
  */
 export function focusView(viewId) {
-    const root = activeLayout().docked;
-    return focusTabWhere(root, (entry) => entry.viewId === viewId);
+    const tree = activeLayout();
+    if (focusTabWhere(tree.docked, (entry) => entry.viewId === viewId))
+        return true;
+    return focusTabInFloats(tree, (entry) => entry.viewId === viewId);
 }
 /** Walk the tree looking for a tab entry that satisfies `pred`, activate it. */
 function focusTabWhere(node, pred) {
@@ -75,6 +80,16 @@ function focusTabWhere(node, pred) {
     }
     return false;
 }
+/** Search floats for a matching tab; activate it and raise the float. */
+function focusTabInFloats(tree, pred) {
+    for (const floatEntry of tree.floats) {
+        if (focusTabWhere(floatEntry.content, pred)) {
+            floatManager.focus(floatEntry.id);
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Collapse a child of a split node at the given path. Returns true if
  * the split was found and the child was collapsed.
@@ -115,10 +130,13 @@ function setCollapsed(splitPath, childIndex, value) {
  * the sole authority on tree mutations.
  */
 export async function closeTab(slotId) {
-    const root = activeLayout().docked;
+    const tree = activeLayout();
+    const root = tree.docked;
     const located = findTabBySlotId(root, slotId);
-    if (!located)
-        return false;
+    // Not found in docked tree — check floats.
+    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.
@@ -143,6 +161,39 @@ export async function closeTab(slotId) {
     cleanupTree(root);
     return true;
 }
+/**
+ * Close a tab that lives inside a float entry. Float tabs are
+ * auto-closable (views gain closability when mounted in a float) but
+ * guarded canClose() on the view handle is still respected.
+ * Closing the last tab in a float removes the entire float.
+ */
+async function closeFloatTab(tree, slotId) {
+    for (const entry of tree.floats) {
+        const located = findTabBySlotId(entry.content, slotId);
+        if (!located)
+            continue;
+        // Respect guarded canClose() if the view declared one.
+        const handle = getSlotHandle(slotId);
+        const closable = handle === null || handle === void 0 ? void 0 : handle.closable;
+        if (typeof closable === 'object') {
+            const allowed = await closable.canClose();
+            if (!allowed)
+                return false;
+            // Re-verify after async gap.
+            if (!findTabBySlotId(entry.content, slotId))
+                return false;
+        }
+        // Remove the tab from the float's content tree.
+        removeTabBySlotId(entry.content, slotId);
+        // If the float's content is now empty, remove the entire float.
+        const tabs = entry.content.type === 'tabs' ? entry.content : null;
+        if (!tabs || tabs.tabs.length === 0) {
+            floatManager.close(entry.id);
+        }
+        return true;
+    }
+    return false;
+}
 function findFirstTabsNode(node) {
     if (node.type === 'tabs')
         return node;

package/dist/layout/ops.js

@@ -195,6 +195,24 @@ export function makeSplitWithNewTab(existing, entry, side) {
         children,
     };
 }
+/**
+ * Shallow-clone a layout node. Used by splitNodeAtPath's root case to
+ * break the circular reference that would occur if the root object
+ * (mutated in-place) were embedded as its own child.
+ */
+function snapshotNode(node) {
+    if (node.type === 'tabs')
+        return Object.assign(Object.assign({}, node), { tabs: [...node.tabs] });
+    if (node.type === 'split') {
+        const clone = Object.assign(Object.assign({}, node), { children: [...node.children], sizes: [...node.sizes] });
+        if (node.pinned)
+            clone.pinned = [...node.pinned];
+        if (node.collapsed)
+            clone.collapsed = [...node.collapsed];
+        return clone;
+    }
+    return Object.assign({}, node); // slot — plain shallow copy
+}
 /**
  * Apply a slot-split as a tree mutation: find the target node at the
  * given path and replace it with a new split. Handles the root case
@@ -205,14 +223,13 @@ export function splitNodeAtPath(root, path, entry, side) {
     const target = nodeAtPath(root, path);
     if (!target)
         return;
-    const replacement = makeSplitWithNewTab(target, entry, side);
     if (path.length === 0) {
-        // Replace root contents in place. The root is a discriminated
-        // union; to rewrite it we cast once through `unknown` and then to
-        // a loose record shape, overwrite fields, and clear stale keys
-        // from the previous node kind so the union stays well-formed.
+        // Root case: target IS root. Snapshot it so makeSplitWithNewTab
+        // embeds the clone, not root itself — avoids a circular reference
+        // when we Object.assign the replacement back onto root.
+        const snapshot = snapshotNode(target);
+        const replacement = makeSplitWithNewTab(snapshot, entry, side);
         const rootAsRecord = root;
-        // Clear stale keys first so Object.assign doesn't leave a hybrid.
         delete rootAsRecord.tabs;
         delete rootAsRecord.activeTab;
         delete rootAsRecord.slotId;
@@ -220,10 +237,12 @@ export function splitNodeAtPath(root, path, entry, side) {
         delete rootAsRecord.direction;
         delete rootAsRecord.sizes;
         delete rootAsRecord.pinned;
+        delete rootAsRecord.collapsed;
         delete rootAsRecord.children;
         Object.assign(rootAsRecord, replacement);
         return;
     }
+    const replacement = makeSplitWithNewTab(target, entry, side);
     const parentPath = path.slice(0, -1);
     const indexInParent = path[path.length - 1];
     const parent = nodeAtPath(root, parentPath);

package/dist/layout/ops.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { findTabInTree } from './ops';
+import { findTabInTree, splitNodeAtPath, cleanupTree, findTabBySlotId } from './ops';
 describe('findTabInTree', () => {
     const tree = {
         docked: {
@@ -34,3 +34,53 @@ describe('findTabInTree', () => {
         expect(findTabInTree(tree, 'nonexistent')).toBeNull();
     });
 });
+describe('splitNodeAtPath — root case (path = [])', () => {
+    it('does not create a circular reference when splitting the root', () => {
+        // splitNodeAtPath mutates root in-place (tabs → split). Cast to
+        // LayoutNode so TS doesn't narrow from the initializer.
+        const root = {
+            type: 'tabs',
+            tabs: [{ slotId: 's1', viewId: 'v1', label: 'One' }],
+            activeTab: 0,
+        };
+        const entry = { slotId: 's2', viewId: 'v2', label: 'Two' };
+        splitNodeAtPath(root, [], entry, 'right');
+        // After split, root should be a split node with two children.
+        // Neither child should be root itself (no circular ref).
+        expect(root.type).toBe('split');
+        if (root.type === 'split') {
+            for (const child of root.children) {
+                expect(child).not.toBe(root);
+            }
+        }
+    });
+    it('cleanupTree does not infinite-loop after splitting the root', () => {
+        const root = {
+            type: 'tabs',
+            tabs: [{ slotId: 's1', viewId: 'v1', label: 'One' }],
+            activeTab: 0,
+        };
+        const entry = { slotId: 's2', viewId: 'v2', label: 'Two' };
+        splitNodeAtPath(root, [], entry, 'right');
+        // This must terminate. Before the fix it infinite-loops.
+        cleanupTree(root);
+        // Both tabs should still be findable.
+        expect(findTabBySlotId(root, 's1')).not.toBeNull();
+        expect(findTabBySlotId(root, 's2')).not.toBeNull();
+    });
+    it('works when root is a slot leaf', () => {
+        const root = {
+            type: 'slot',
+            slotId: 'leaf',
+            viewId: 'v',
+        };
+        const entry = { slotId: 's2', viewId: 'v2', label: 'Two' };
+        splitNodeAtPath(root, [], entry, 'bottom');
+        expect(root.type).toBe('split');
+        if (root.type === 'split') {
+            for (const child of root.children) {
+                expect(child).not.toBe(root);
+            }
+        }
+    });
+});

package/dist/layout/slotHostPool.svelte.js

@@ -113,7 +113,7 @@ function createHost(slotId, viewId, label) {
             },
         };
         entry.handle = factory === null || factory === void 0 ? void 0 : factory.mount(host, ctx);
-        if ((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) {
+        if (((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) || slotId.startsWith('float:')) {
             closableState[slotId] = true;
         }
         // The pool owns the ResizeObserver so its lifetime matches the

package/dist/layout/store.svelte.js

@@ -50,10 +50,10 @@ const HOME_LAYOUT = {
     slotId: 'sh3core.home',
     viewId: 'sh3core:home',
 };
-const HOME_TREE = {
+const HOME_TREE = $state({
     docked: HOME_LAYOUT,
     floats: [],
-};
+});
 let appEntry = $state(null);
 let activeRoot = $state('home');
 // ---------- read-side adapter helpers -------------------------------------

package/dist/overlays/FloatFrame.svelte

@@ -30,6 +30,7 @@
 
   function onHeaderPointerDown(e: PointerEvent): void {
     if (e.button !== 0) return;
+    if ((e.target as HTMLElement).closest('.sh3-float-close')) return;
     const target = e.currentTarget as HTMLElement;
     target.setPointerCapture(e.pointerId);
     dragging = true;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.7.1";
+export declare const VERSION = "0.7.3";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.7.1';
+export const VERSION = '0.7.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "type": "module",
   "files": [
     "dist"