sh3-core 0.15.0 → 0.15.2

package/dist/app/store/verbs.js

@@ -17,6 +17,7 @@ function findInstalled(id) {
 export const installVerb = {
     name: 'install',
     summary: 'Install a package by id from the catalog.',
+    programmatic: true,
     async run(ctx, args) {
         var _a, _b, _c;
         const id = args[0];
@@ -117,6 +118,7 @@ export const installVerb = {
 export const uninstallVerb = {
     name: 'uninstall',
     summary: 'Uninstall an installed package by id.',
+    programmatic: true,
     async run(ctx, args) {
         const id = args[0];
         if (!id) {
@@ -168,6 +170,7 @@ export const updateVerb = {
     summary: 'Update an installed package (sh3-store:update <id> [version]). When ' +
         'version is omitted, bumps to latest; with a version, installs that ' +
         'exact version (downgrade or same-version reinstall allowed).',
+    programmatic: true,
     async run(ctx, args) {
         var _a, _b;
         const id = args[0];
@@ -243,6 +246,7 @@ export const updateVerb = {
 export const appinfoVerb = {
     name: 'appinfo',
     summary: 'Show info about a package (installed status, version, catalog details).',
+    programmatic: true,
     async run(ctx, args) {
         const id = args[0];
         if (!id) {

package/dist/app-appearance/appearanceShard.svelte.js

@@ -9,8 +9,8 @@ import { VERSION } from '../version';
 import { listRegisteredApps } from '../api';
 import { getSelection } from '../actions/selection.svelte';
 import { modalManager } from '../overlays/modal';
-import AppAppearanceModal from './AppAppearanceModal.svelte';
-import { __bindZone, __unbindZone, } from './appearanceState.svelte';
+import EntityAppearanceModal from '../overlays/EntityAppearanceModal.svelte';
+import { __bindZone, __unbindZone, getAppearance, setAppearance, } from './appearanceState.svelte';
 function readSelection() {
     const sel = getSelection();
     if (!sel || sel.type !== 'app')
@@ -18,16 +18,29 @@ function readSelection() {
     return sel.ref;
 }
 function runCustomize(_ctx) {
-    var _a;
+    var _a, _b, _c;
     const ref = readSelection();
     if (!ref)
         return;
     const m = listRegisteredApps().find((x) => x.id === ref.appId);
+    const appLabel = (_a = m === null || m === void 0 ? void 0 : m.label) !== null && _a !== void 0 ? _a : ref.appId;
+    const manifestIcon = (_b = m === null || m === void 0 ? void 0 : m.icon) !== null && _b !== void 0 ? _b : 'box';
+    const initial = getAppearance(ref.appId);
     const props = {
-        appId: ref.appId,
-        appLabel: (_a = m === null || m === void 0 ? void 0 : m.label) !== null && _a !== void 0 ? _a : ref.appId,
+        entityLabel: (_c = initial === null || initial === void 0 ? void 0 : initial.label) !== null && _c !== void 0 ? _c : appLabel,
+        initialAppearance: initial,
+        defaultIcon: manifestIcon,
+        requireLabel: false,
+        onSave: (next) => {
+            setAppearance(ref.appId, {
+                label: next.label === '' ? undefined : next.label,
+                icon: next.icon,
+                color: next.color,
+            });
+        },
+        onReset: () => setAppearance(ref.appId, undefined),
     };
-    modalManager.open(AppAppearanceModal, props);
+    modalManager.open(EntityAppearanceModal, props);
 }
 export const appearanceShard = {
     manifest: {

package/dist/app-appearance/appearanceState.svelte.js

@@ -1,9 +1,9 @@
 /*
  * Per-user-per-browser visual overrides for apps. The store + helpers
  * live separately from the shard so the state can be unit-tested without
- * booting the shard system, and so the AppAppearanceModal can import
- * get/set without creating an import cycle through the shard's modal
- * import.
+ * booting the shard system, and so the appearanceShard's runCustomize
+ * can import get/set without creating an import cycle through the
+ * shard's modal import.
  *
  * EXPLICITLY TEMPORARY. A future ADR is expected to add icon/color
  * fields to the app manifest itself.

package/dist/host.js

@@ -24,6 +24,7 @@ import { shellShard } from './shell-shard/shellShard.svelte';
 import { storeShard } from './app/store/storeShard.svelte';
 import { projectsShard } from './projects-shard/projectsShard.svelte';
 import { appearanceShard } from './app-appearance';
+import { layoutsShard } from './layouts-shard';
 import { __setBackend, backends } from './state/zones.svelte';
 import { loadInstalledPackages } from './registry/installer';
 import { setLocalOwner } from './auth/index';
@@ -70,7 +71,7 @@ export async function bootstrap(config) {
     }
     const exShards = new Set(config === null || config === void 0 ? void 0 : config.excludeShards);
     // 1. Framework-owned shards
-    const frameworkShards = [sh3coreShard, shellShard, storeShard, adminShard, projectsShard, appearanceShard];
+    const frameworkShards = [sh3coreShard, shellShard, storeShard, adminShard, projectsShard, appearanceShard, layoutsShard];
     for (const shard of frameworkShards) {
         if (!exShards.has(shard.manifest.id)) {
             registerShardInternal(shard);

package/dist/layouts-shard/LayoutSaveModal.svelte

@@ -0,0 +1,145 @@
+<script lang="ts">
+  /*
+   * LayoutSaveModal — Save layout as… dialog.
+   *
+   * Receives the floatId of the source float. On mount it reads the live
+   * float entry, runs the standalone filter once, and shows:
+   *   - a name input (default = float title or "Layout {N}")
+   *   - a preview list of view ids being captured
+   *   - Save / Cancel
+   *
+   * If the source float has closed by the time the modal is open, or the
+   * filter drops everything, Save is disabled with an inline message.
+   *
+   * On Save the modal calls the supplied onConfirm(name) callback —
+   * the shard does the actual capture via captureFromFloat and addLayout.
+   */
+
+  import { untrack } from 'svelte';
+  import type { LayoutNode } from '../layout/types';
+  import { floatManager } from '../overlays/float';
+  import { filterToStandalone, type IsStandalone } from './filter';
+
+  interface Props {
+    floatId: string;
+    isStandalone: IsStandalone;
+    resolveLabel: (viewId: string) => string;
+    defaultName: string;
+    onConfirm(name: string): void;
+    close: () => void;
+  }
+
+  let { floatId, isStandalone, resolveLabel, defaultName, onConfirm, close }: Props = $props();
+
+  const sourceContent = untrack(() =>
+    floatManager.list().find((f) => f.id === floatId)?.content ?? null,
+  );
+
+  const filtered = $derived<LayoutNode | null>(
+    sourceContent ? filterToStandalone(sourceContent, isStandalone) : null,
+  );
+
+  const previewIds = $derived<string[]>(filtered ? collectViewIds(filtered) : []);
+  const sourceMissing = $derived(sourceContent === null);
+  const filterEmpty = $derived(!sourceMissing && filtered === null);
+
+  let name = $state<string>(untrack(() => defaultName));
+  const saveDisabled = $derived(name.trim() === '' || sourceMissing || filterEmpty);
+
+  function collectViewIds(node: LayoutNode): string[] {
+    if (node.type === 'slot') return node.viewId ? [node.viewId] : [];
+    if (node.type === 'tabs') {
+      const out: string[] = [];
+      for (const t of node.tabs) if (t.viewId) out.push(t.viewId);
+      return out;
+    }
+    return node.children.flatMap(collectViewIds);
+  }
+
+  function save() {
+    if (saveDisabled) return;
+    onConfirm(name.trim());
+    close();
+  }
+</script>
+
+<div class="layout-save">
+  <h2>Save layout as…</h2>
+
+  <label class="row"><span>Name</span>
+    <input
+      type="text"
+      bind:value={name}
+      class="name-input"
+      placeholder="Layout name"
+    />
+  </label>
+
+  {#if sourceMissing}
+    <p class="error">The source float was closed.</p>
+  {:else if filterEmpty}
+    <p class="error">No standalone views in this float.</p>
+  {:else}
+    <div class="preview">
+      <div class="preview-label">Captured views ({previewIds.length}):</div>
+      <ul class="preview-list">
+        {#each previewIds as viewId}
+          <li>{resolveLabel(viewId)} <span class="muted">({viewId})</span></li>
+        {/each}
+      </ul>
+    </div>
+  {/if}
+
+  <div class="actions">
+    <button type="button" class="primary" onclick={save} disabled={saveDisabled}>Save</button>
+    <button type="button" onclick={() => close()}>Cancel</button>
+  </div>
+</div>
+
+<style>
+  .layout-save {
+    padding: 16px 20px;
+    max-width: 460px;
+    color: var(--shell-fg);
+    background: var(--shell-bg);
+    font: inherit;
+  }
+  h2 { margin: 0 0 12px; font-size: 16px; }
+  .row { display: flex; flex-direction: column; gap: 4px; margin-bottom: 12px; font-size: 13px; }
+  .row span { color: var(--shell-fg-muted); }
+  .name-input {
+    background: var(--shell-bg-elevated);
+    color: var(--shell-fg);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-radius-sm, 3px);
+    padding: 6px 8px; font: inherit; font-size: 13px;
+  }
+  .preview { margin: 4px 0 12px; }
+  .preview-label { font-size: 12px; color: var(--shell-fg-muted); margin-bottom: 4px; }
+  .preview-list {
+    list-style: none; padding: 0; margin: 0;
+    font-size: 12px; max-height: 160px; overflow: auto;
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-radius-sm, 3px);
+    background: var(--shell-bg-elevated);
+  }
+  .preview-list li { padding: 4px 8px; border-bottom: 1px solid var(--shell-border); }
+  .preview-list li:last-child { border-bottom: 0; }
+  .muted { color: var(--shell-fg-muted); }
+  .error {
+    color: var(--shell-fg-muted);
+    font-style: italic;
+    margin: 4px 0 12px;
+  }
+  .actions { display: flex; gap: 8px; margin-top: 8px; }
+  .actions button {
+    background: var(--shell-bg-elevated);
+    color: var(--shell-fg);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-radius-sm, 3px);
+    padding: 6px 14px; font: inherit; cursor: pointer;
+  }
+  .actions button.primary { background: var(--shell-accent); color: #fff; border-color: var(--shell-accent); }
+  .actions button:hover { border-color: var(--shell-accent); }
+  .actions button:disabled { opacity: 0.5; cursor: not-allowed; }
+</style>

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

@@ -0,0 +1,12 @@
+import { type IsStandalone } from './filter';
+interface Props {
+    floatId: string;
+    isStandalone: IsStandalone;
+    resolveLabel: (viewId: string) => string;
+    defaultName: string;
+    onConfirm(name: string): void;
+    close: () => void;
+}
+declare const LayoutSaveModal: import("svelte").Component<Props, {}, "">;
+type LayoutSaveModal = ReturnType<typeof LayoutSaveModal>;
+export default LayoutSaveModal;

package/dist/layouts-shard/LayoutsSection.svelte

@@ -0,0 +1,142 @@
+<script lang="ts">
+  /*
+   * Saved-layouts section for ShellHome. Renders one card per SavedLayout.
+   * Click → restoreToFloat. Right-click sets a typed selection so card
+   * actions (Customize, Delete) can recover the layoutId.
+   */
+
+  import { getLayouts } from './layoutsState.svelte';
+  import { restoreToFloat } from './layoutsApi';
+  import { listStandaloneViews } from '../shards/activate.svelte';
+  import { toastManager } from '../overlays/toast';
+  import { shell } from '../shellRuntime.svelte';
+  import { makeSelectionApi } from '../actions/selection.svelte';
+  import iconsUrl from '../assets/icons.svg';
+
+  const layouts = $derived(getLayouts());
+  const selection = makeSelectionApi('__layouts__');
+
+  function isStandalone(viewId: string): boolean {
+    return listStandaloneViews().some((v) => v.viewId === viewId);
+  }
+
+  function emitToast(message: string, level: 'info' | 'warn' | 'error'): void {
+    toastManager.notify(message, { level });
+  }
+
+  function open(id: string): void {
+    const live = getLayouts().find((l) => l.id === id);
+    if (live) restoreToFloat(live, isStandalone, emitToast);
+  }
+
+  function openCardContextMenu(event: MouseEvent, layoutId: string): void {
+    event.preventDefault();
+    selection.set({ type: 'saved-layout', ref: { layoutId } });
+    shell.actions.openContextMenu({
+      x: event.clientX,
+      y: event.clientY,
+      scope: { element: 'saved-layout' },
+    });
+  }
+</script>
+
+{#if layouts.length > 0}
+  <section class="saved-layouts-section">
+    <h2 class="saved-layouts-heading">Saved Layouts</h2>
+    <div class="saved-layouts-grid">
+      {#each layouts as layout (layout.id)}
+        <button
+          type="button"
+          class="saved-layout-card"
+          class:saved-layout-card--tinted={layout.appearance?.color}
+          style:--card-color={layout.appearance?.color ?? 'transparent'}
+          data-sh3-scope="element:saved-layout"
+          data-saved-layout-id={layout.id}
+          onclick={() => open(layout.id)}
+          oncontextmenu={(e) => openCardContextMenu(e, layout.id)}
+        >
+          <span class="saved-layout-card-square">
+            <svg class="saved-layout-card-icon">
+              <use href="{iconsUrl}#{layout.appearance?.icon ?? 'eye'}" />
+            </svg>
+          </span>
+          <span class="saved-layout-card-label">{layout.name}</span>
+        </button>
+      {/each}
+    </div>
+  </section>
+{/if}
+
+<style>
+  .saved-layouts-section {
+    width: 100%;
+    max-width: 720px;
+    margin-bottom: 28px;
+  }
+  .saved-layouts-heading {
+    font-size: 13px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--shell-fg-subtle);
+    margin: 0 0 12px;
+  }
+  .saved-layouts-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(84px, 1fr));
+    gap: 18px 14px;
+  }
+  .saved-layout-card {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 6px;
+    padding: 0;
+    background: transparent;
+    border: none;
+    color: inherit;
+    font: inherit;
+    cursor: pointer;
+  }
+  .saved-layout-card-square {
+    width: 64px;
+    height: 64px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--saved-layout-color, var(--shell-grad-bg-elevated, var(--shell-bg-elevated)));
+    border: 1px dashed var(--shell-border);
+    border-radius: var(--shell-radius-md);
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.25), 0 1px 2px rgba(0, 0, 0, 0.15);
+    transition: transform 120ms ease, border-color 120ms ease, box-shadow 120ms ease, background 120ms ease;
+  }
+  .saved-layout-card:hover .saved-layout-card-square {
+    border-color: var(--shell-accent);
+    transform: translateY(-1px);
+    box-shadow:
+      0 6px 14px rgba(0, 0, 0, 0.3),
+      0 0 0 1px color-mix(in srgb, var(--shell-accent) 35%, transparent),
+      0 4px 12px color-mix(in srgb, var(--shell-accent) 18%, transparent);
+  }
+  .saved-layout-card-icon {
+    width: 28px;
+    height: 28px;
+    color: var(--shell-fg);
+  }
+  .saved-layout-card-label {
+    font-weight: 600;
+    font-size: 11px;
+    line-height: 1.2;
+    text-align: center;
+    overflow: hidden;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 2;
+    line-clamp: 2;
+    word-break: break-word;
+  }
+  .saved-layout-card--tinted .saved-layout-card-square {
+    background: var(--card-color);
+    border-style: solid;
+  }
+</style>

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

@@ -0,0 +1,3 @@
+declare const LayoutsSection: import("svelte").Component<Record<string, never>, {}, "">;
+type LayoutsSection = ReturnType<typeof LayoutsSection>;
+export default LayoutsSection;

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

@@ -0,0 +1,3 @@
+import type { LayoutNode } from '../layout/types';
+export type IsStandalone = (viewId: string) => boolean;
+export declare function filterToStandalone(node: LayoutNode, isStandalone: IsStandalone): LayoutNode | null;

package/dist/layouts-shard/filter.js

@@ -0,0 +1,66 @@
+/*
+ * filterToStandalone — pure tree-walk that drops every tab/slot whose
+ * viewId is not a standalone view, prunes empty branches, and flattens
+ * 1-child splits. Returns null when the entire tree filters out.
+ *
+ * Used at save time (against the live float content) and at restore time
+ * (defensive re-pass against shard uninstalls / view-id renames between
+ * save and restore). Idempotent on already-filtered trees.
+ *
+ * The standalone-ness predicate is injected so this module stays pure —
+ * the actual list comes from `listStandaloneViews()` at the call site.
+ */
+export function filterToStandalone(node, isStandalone) {
+    var _a;
+    if (node.type === 'slot') {
+        if (node.viewId === null)
+            return null;
+        if (!isStandalone(node.viewId))
+            return null;
+        return node;
+    }
+    if (node.type === 'tabs') {
+        const keptTabs = [];
+        let originalActiveSurvived = false;
+        let originalActiveNewIndex = 0;
+        for (let i = 0; i < node.tabs.length; i++) {
+            const tab = node.tabs[i];
+            if (tab.viewId === null)
+                continue;
+            if (!isStandalone(tab.viewId))
+                continue;
+            if (i === node.activeTab) {
+                originalActiveSurvived = true;
+                originalActiveNewIndex = keptTabs.length;
+            }
+            keptTabs.push(tab);
+        }
+        if (keptTabs.length === 0)
+            return null;
+        return {
+            type: 'tabs',
+            tabs: keptTabs,
+            activeTab: originalActiveSurvived ? originalActiveNewIndex : 0,
+        };
+    }
+    // split
+    const keptChildren = [];
+    const keptSizes = [];
+    for (let i = 0; i < node.children.length; i++) {
+        const child = filterToStandalone(node.children[i], isStandalone);
+        if (child === null)
+            continue;
+        keptChildren.push(child);
+        keptSizes.push((_a = node.sizes[i]) !== null && _a !== void 0 ? _a : 1);
+    }
+    if (keptChildren.length === 0)
+        return null;
+    if (keptChildren.length === 1)
+        return keptChildren[0];
+    return {
+        type: 'split',
+        direction: node.direction,
+        sizes: keptSizes,
+        children: keptChildren,
+    };
+}

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

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

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

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest';
+import { filterToStandalone } from './filter';
+const STANDALONE = new Set(['shell:terminal', 'graphlive:hierarchy']);
+const isStandalone = (viewId) => STANDALONE.has(viewId);
+describe('filterToStandalone', () => {
+    it('returns null for an empty slot', () => {
+        const tree = { type: 'slot', slotId: 's', viewId: null };
+        expect(filterToStandalone(tree, isStandalone)).toBeNull();
+    });
+    it('returns null for a slot whose view is non-standalone', () => {
+        const tree = { type: 'slot', slotId: 's', viewId: 'app-only:view' };
+        expect(filterToStandalone(tree, isStandalone)).toBeNull();
+    });
+    it('passes through a slot with a standalone view', () => {
+        const tree = { type: 'slot', slotId: 's', viewId: 'shell:terminal' };
+        expect(filterToStandalone(tree, isStandalone)).toEqual(tree);
+    });
+    it('drops non-standalone tabs from a tabs node', () => {
+        const tree = {
+            type: 'tabs',
+            activeTab: 0,
+            tabs: [
+                { slotId: 'a', viewId: 'shell:terminal', label: 'Shell' },
+                { slotId: 'b', viewId: 'app-only:view', label: 'App' },
+                { slotId: 'c', viewId: 'graphlive:hierarchy', label: 'Graph' },
+            ],
+        };
+        const out = filterToStandalone(tree, isStandalone);
+        expect(out).toEqual({
+            type: 'tabs',
+            activeTab: 0,
+            tabs: [
+                { slotId: 'a', viewId: 'shell:terminal', label: 'Shell' },
+                { slotId: 'c', viewId: 'graphlive:hierarchy', label: 'Graph' },
+            ],
+        });
+    });
+    it('clamps activeTab when the original active was filtered out', () => {
+        const tree = {
+            type: 'tabs',
+            activeTab: 1,
+            tabs: [
+                { slotId: 'a', viewId: 'shell:terminal', label: 'Shell' },
+                { slotId: 'b', viewId: 'app-only:view', label: 'App' },
+            ],
+        };
+        const out = filterToStandalone(tree, isStandalone);
+        expect(out).not.toBeNull();
+        if (out && out.type === 'tabs')
+            expect(out.activeTab).toBe(0);
+    });
+    it('returns null for a tabs node whose tabs all filter out', () => {
+        const tree = {
+            type: 'tabs',
+            activeTab: 0,
+            tabs: [
+                { slotId: 'a', viewId: 'app-only:view', label: 'App' },
+            ],
+        };
+        expect(filterToStandalone(tree, isStandalone)).toBeNull();
+    });
+    it('flattens a 1-child split to that child', () => {
+        const tree = {
+            type: 'split',
+            direction: 'horizontal',
+            sizes: [1, 1],
+            children: [
+                { type: 'slot', slotId: 'a', viewId: 'shell:terminal' },
+                { type: 'slot', slotId: 'b', viewId: 'app-only:view' },
+            ],
+        };
+        const out = filterToStandalone(tree, isStandalone);
+        expect(out).toEqual({ type: 'slot', slotId: 'a', viewId: 'shell:terminal' });
+    });
+    it('returns null for a split whose children all filter out', () => {
+        const tree = {
+            type: 'split',
+            direction: 'horizontal',
+            sizes: [1, 1],
+            children: [
+                { type: 'slot', slotId: 'a', viewId: 'app-only:view' },
+                { type: 'slot', slotId: 'b', viewId: null },
+            ],
+        };
+        expect(filterToStandalone(tree, isStandalone)).toBeNull();
+    });
+    it('preserves split sizes for surviving children', () => {
+        const tree = {
+            type: 'split',
+            direction: 'vertical',
+            sizes: [1, 2, 3],
+            children: [
+                { type: 'slot', slotId: 'a', viewId: 'shell:terminal' },
+                { type: 'slot', slotId: 'b', viewId: 'app-only:view' },
+                { type: 'slot', slotId: 'c', viewId: 'graphlive:hierarchy' },
+            ],
+        };
+        const out = filterToStandalone(tree, isStandalone);
+        expect(out).toEqual({
+            type: 'split',
+            direction: 'vertical',
+            sizes: [1, 3],
+            children: [
+                { type: 'slot', slotId: 'a', viewId: 'shell:terminal' },
+                { type: 'slot', slotId: 'c', viewId: 'graphlive:hierarchy' },
+            ],
+        });
+    });
+    it('is idempotent on already-filtered trees', () => {
+        const tree = {
+            type: 'split',
+            direction: 'horizontal',
+            sizes: [1, 1],
+            children: [
+                { type: 'slot', slotId: 'a', viewId: 'shell:terminal' },
+                { type: 'slot', slotId: 'b', viewId: 'graphlive:hierarchy' },
+            ],
+        };
+        const once = filterToStandalone(tree, isStandalone);
+        const twice = filterToStandalone(once, isStandalone);
+        expect(twice).toEqual(once);
+    });
+});

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

@@ -0,0 +1 @@
+export { layoutsShard } from './layoutsShard.svelte';

package/dist/layouts-shard/index.js

@@ -0,0 +1 @@
+export { layoutsShard } from './layoutsShard.svelte';

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

@@ -0,0 +1,12 @@
+import type { LayoutNode } from '../layout/types';
+import type { SavedLayout } from './types';
+import { type IsStandalone } from './filter';
+export type ToastEmit = (message: string, level: 'info' | 'warn' | 'error') => void;
+export declare function captureFromFloat(floatId: string, isStandalone: IsStandalone): {
+    size: {
+        w: number;
+        h: number;
+    };
+    content: LayoutNode;
+} | null;
+export declare function restoreToFloat(layout: SavedLayout, isStandalone: IsStandalone, toast: ToastEmit): string;

package/dist/layouts-shard/layoutsApi.js

@@ -0,0 +1,41 @@
+/*
+ * captureFromFloat / restoreToFloat — orchestration glue between the
+ * live float manager, the standalone-view filter, and the floats overlay.
+ *
+ * Pure orchestration: the standalone predicate and the toast emitter are
+ * injected so this file is testable in the dom project without booting
+ * the full shard system. The shard wires the real lookups in.
+ */
+import { floatManager } from '../overlays/float';
+import { filterToStandalone } from './filter';
+// JSON round-trip clone. structuredClone can't traverse Svelte's $state
+// proxies (saved layouts live in the user-zone proxy), so we route
+// through JSON. LayoutNode is intentionally JSON-safe — TabEntry.meta is
+// ephemeral and not part of a saved/restored layout.
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function captureFromFloat(floatId, isStandalone) {
+    const entry = floatManager.list().find((f) => f.id === floatId);
+    if (!entry)
+        return null;
+    const filtered = filterToStandalone(entry.content, isStandalone);
+    if (filtered === null)
+        return null;
+    return {
+        size: { w: entry.size.w, h: entry.size.h },
+        content: deepClone(filtered),
+    };
+}
+export function restoreToFloat(layout, isStandalone, toast) {
+    const filtered = filterToStandalone(layout.content, isStandalone);
+    if (filtered === null) {
+        toast(`Saved layout "${layout.name}" has no available standalone views`, 'warn');
+        return '';
+    }
+    return floatManager.openWithContent({
+        content: deepClone(filtered),
+        size: { w: layout.size.w, h: layout.size.h },
+        title: layout.name,
+    });
+}

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

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