sh3-core 0.8.0 → 0.8.1

package/dist/layout/inspection.d.ts

@@ -50,6 +50,23 @@ export declare function expandChild(splitPath: number[], childIndex: number): bo
  * the sole authority on tree mutations.
  */
 export declare function closeTab(slotId: string): Promise<boolean>;
+/**
+ * Pop a docked tab out into a new float. Locates the tab by `slotId` in
+ * the currently-rendered docked tree, removes it (preserving viewId +
+ * meta), and opens a float with the same view. Returns the new floatId
+ * on success, or null if the slot wasn't found in the docked tree.
+ *
+ * Guarded canClose() is NOT consulted — popout is not a close. The slot
+ * is recreated in the float with a fresh slotId, so the view is remounted.
+ */
+export declare function popoutView(slotId: string): string | null;
+/**
+ * Dock a float back into the currently-rendered layout. The float's
+ * active tab is appended to the first tabs group (same policy as
+ * `dockIntoActiveLayout`). Returns true on success. The float is closed
+ * after its content is transferred.
+ */
+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+` shell hotkey and other "just put it

package/dist/layout/inspection.js

@@ -194,6 +194,59 @@ async function closeFloatTab(tree, slotId) {
     }
     return false;
 }
+/**
+ * Pop a docked tab out into a new float. Locates the tab by `slotId` in
+ * the currently-rendered docked tree, removes it (preserving viewId +
+ * meta), and opens a float with the same view. Returns the new floatId
+ * on success, or null if the slot wasn't found in the docked tree.
+ *
+ * Guarded canClose() is NOT consulted — popout is not a close. The slot
+ * is recreated in the float with a fresh slotId, so the view is remounted.
+ */
+export function popoutView(slotId) {
+    const tree = activeLayout();
+    const located = findTabBySlotId(tree.docked, slotId);
+    if (!located)
+        return null;
+    const entry = located.entry;
+    const viewId = entry.viewId;
+    if (!viewId)
+        return null;
+    const title = entry.label;
+    const meta = entry.meta;
+    removeTabBySlotId(tree.docked, slotId);
+    cleanupTree(tree.docked);
+    return floatManager.open(viewId, { title, meta });
+}
+/**
+ * Dock a float back into the currently-rendered layout. The float's
+ * active tab is appended to the first tabs group (same policy as
+ * `dockIntoActiveLayout`). Returns true on success. The float is closed
+ * after its content is transferred.
+ */
+export function dockFloat(floatId) {
+    var _a, _b;
+    const tree = activeLayout();
+    const floatEntry = tree.floats.find((f) => f.id === floatId);
+    if (!floatEntry)
+        return false;
+    const content = floatEntry.content;
+    const tabs = content.type === 'tabs' ? content : null;
+    if (!tabs || tabs.tabs.length === 0) {
+        floatManager.close(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({
+        slotId: entry.slotId,
+        viewId: entry.viewId,
+        label: entry.label,
+        meta: entry.meta,
+    });
+    if (ok)
+        floatManager.close(floatId);
+    return ok;
+}
 function findFirstTabsNode(node) {
     if (node.type === 'tabs')
         return node;

package/dist/shards/activate-browse.test.d.ts

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

package/dist/shards/activate-browse.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { __setDocumentBackend, __setTenantId } from '../documents/config';
+import { registerShard, activateShard, __resetShardRegistryForTest } from './activate.svelte';
+import { PERMISSION_DOCUMENTS_BROWSE } from '../documents/types';
+describe('ctx.browse permission gating', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-a');
+    });
+    it('is undefined when permission is absent', async () => {
+        let captured = null;
+        registerShard({
+            manifest: { id: 'no-browse', label: 'n', version: '0.0.0', views: [] },
+            activate(ctx) { captured = ctx; },
+        });
+        await activateShard('no-browse');
+        expect(captured.browse).toBeUndefined();
+    });
+    it('is defined when documents:browse is declared', async () => {
+        var _a, _b, _c;
+        let captured = null;
+        registerShard({
+            manifest: {
+                id: 'has-browse', label: 'b', version: '0.0.0', views: [],
+                permissions: [PERMISSION_DOCUMENTS_BROWSE],
+            },
+            activate(ctx) { captured = ctx; },
+        });
+        await activateShard('has-browse');
+        expect(typeof ((_a = captured.browse) === null || _a === void 0 ? void 0 : _a.listDocuments)).toBe('function');
+        expect(typeof ((_b = captured.browse) === null || _b === void 0 ? void 0 : _b.watchDocuments)).toBe('function');
+        expect(typeof ((_c = captured.browse) === null || _c === void 0 ? void 0 : _c.listShards)).toBe('function');
+    });
+});

package/dist/shards/activate-sync-registry.test.d.ts

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

package/dist/shards/activate-sync-registry.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { __setDocumentBackend, __setTenantId } from '../documents/config';
+import { __resetSyncBundlesForTest } from '../documents/sync/singleton';
+import { registerShard, activateShard, __resetShardRegistryForTest } from './activate.svelte';
+import { PERMISSION_DOCUMENTS_BROWSE } from '../documents/types';
+describe('ctx.syncRegistry', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __resetSyncBundlesForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-a');
+    });
+    it('is undefined without documents:browse', async () => {
+        let captured = null;
+        registerShard({
+            manifest: { id: 'no-obs', label: 'n', version: '0.0.0', views: [] },
+            activate(ctx) { captured = ctx; },
+        });
+        await activateShard('no-obs');
+        expect(captured.syncRegistry).toBeUndefined();
+    });
+    it('is available under documents:browse', async () => {
+        let captured = null;
+        registerShard({
+            manifest: {
+                id: 'obs', label: 'o', version: '0.0.0', views: [],
+                permissions: [PERMISSION_DOCUMENTS_BROWSE],
+            },
+            activate(ctx) { captured = ctx; },
+        });
+        await activateShard('obs');
+        const reg = captured.syncRegistry();
+        expect(typeof reg.list).toBe('function');
+        expect(typeof reg.listConflicts).toBe('function');
+        expect(typeof reg.listAllConnectorIds).toBe('function');
+        expect(typeof reg.revoke).toBe('function');
+        // Functional smoke: empty registry should return []
+        expect(await reg.list()).toEqual([]);
+        expect(await reg.listConflicts()).toEqual([]);
+    });
+});

package/dist/shards/activate-tenantid.test.d.ts

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

package/dist/shards/activate-tenantid.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { __setDocumentBackend, __setTenantId } from '../documents/config';
+import { registerShard, activateShard, __resetShardRegistryForTest } from './activate.svelte';
+describe('ctx.tenantId', () => {
+    beforeEach(() => {
+        __resetShardRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setTenantId('tenant-a');
+    });
+    it('is present unconditionally on ctx', async () => {
+        let captured = null;
+        const shard = {
+            manifest: { id: 'test-tenantid', label: 't', version: '0.0.0', views: [] },
+            activate(ctx) { captured = ctx; },
+        };
+        registerShard(shard);
+        await activateShard('test-tenantid');
+        expect(captured.tenantId).toBe('tenant-a');
+    });
+});

package/dist/shards/activate.svelte.d.ts

@@ -50,6 +50,18 @@ export declare function isActive(id: string): boolean;
  * Used by lifecycle.ts to pass context to `shard.resume()`.
  */
 export declare function getShardContext(id: string): ShardContext | undefined;
+/**
+ * Enumerate every view declared as `standalone` across the currently
+ * active shards. Intended for the `views --standalone` verb and any
+ * launcher UI that wants to surface "summonable" primitives. Only
+ * pulls from `activeShards` — registered-but-inactive shards aren't
+ * ready to mount.
+ */
+export declare function listStandaloneViews(): Array<{
+    shardId: string;
+    viewId: string;
+    label: string;
+}>;
 /**
  * Test-only reset. Tears down any active shard entries (without running
  * deactivate hooks — tests should run deactivate explicitly if they care)

package/dist/shards/activate.svelte.js

@@ -24,8 +24,11 @@ import { isAdmin as checkIsAdmin } from '../auth/index';
 import { createZoneManager } from '../state/manage';
 import { PERMISSION_STATE_MANAGE } from '../state/types';
 import { PERMISSION_DOCUMENTS_SYNC } from '../documents/sync/types';
+import { PERMISSION_DOCUMENTS_BROWSE } from '../documents/types';
+import { createBrowseCapability } from '../documents/browse';
 import { getSyncBundle } from '../documents/sync/singleton';
 import { createSyncHandle } from '../documents/sync/handle';
+import { createSyncRegistryAccessor } from '../documents/sync/observer';
 /**
  * Reactive registry of every shard known to the host. Keys are shard ids.
  * Populated once at boot by the glob-discovery loop in main.ts (through
@@ -68,7 +71,7 @@ export function registerShard(shard) {
  * @throws If the shard is not registered, or if a manifest view has no factory after activation.
  */
 export async function activateShard(id) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const shard = registeredShards.get(id);
     if (!shard) {
         throw new Error(`Cannot activate shard "${id}": not registered`);
@@ -128,10 +131,19 @@ export async function activateShard(id) {
         get isAdmin() {
             return checkIsAdmin();
         },
+        get tenantId() {
+            return getTenantId();
+        },
         zones: ((_a = shard.manifest.permissions) === null || _a === void 0 ? void 0 : _a.includes(PERMISSION_STATE_MANAGE))
             ? createZoneManager()
             : undefined,
-        sync: ((_b = shard.manifest.permissions) === null || _b === void 0 ? void 0 : _b.includes(PERMISSION_DOCUMENTS_SYNC))
+        browse: ((_b = shard.manifest.permissions) === null || _b === void 0 ? void 0 : _b.includes(PERMISSION_DOCUMENTS_BROWSE))
+            ? createBrowseCapability(getTenantId(), getDocumentBackend())
+            : undefined,
+        syncRegistry: ((_c = shard.manifest.permissions) === null || _c === void 0 ? void 0 : _c.includes(PERMISSION_DOCUMENTS_BROWSE))
+            ? createSyncRegistryAccessor(getDocumentBackend(), getTenantId())
+            : undefined,
+        sync: ((_d = shard.manifest.permissions) === null || _d === void 0 ? void 0 : _d.includes(PERMISSION_DOCUMENTS_SYNC))
             ? () => {
                 const backend = getDocumentBackend();
                 const tenantId = getTenantId();
@@ -170,7 +182,7 @@ export async function activateShard(id) {
             console.warn(`[sh3] Failed to hydrate env state for shard "${id}":`, err instanceof Error ? err.message : err);
         }
     }
-    void ((_c = shard.autostart) === null || _c === void 0 ? void 0 : _c.call(shard, ctx));
+    void ((_e = shard.autostart) === null || _e === void 0 ? void 0 : _e.call(shard, ctx));
 }
 /**
  * Deactivate an active shard. Calls `shard.deactivate`, flushes and disposes
@@ -212,6 +224,24 @@ export function getShardContext(id) {
     var _a;
     return (_a = active.get(id)) === null || _a === void 0 ? void 0 : _a.ctx;
 }
+/**
+ * Enumerate every view declared as `standalone` across the currently
+ * active shards. Intended for the `views --standalone` verb and any
+ * launcher UI that wants to surface "summonable" primitives. Only
+ * pulls from `activeShards` — registered-but-inactive shards aren't
+ * ready to mount.
+ */
+export function listStandaloneViews() {
+    const out = [];
+    for (const shard of activeShards.values()) {
+        for (const view of shard.manifest.views) {
+            if (view.standalone) {
+                out.push({ shardId: shard.manifest.id, viewId: view.id, label: view.label });
+            }
+        }
+    }
+    return out;
+}
 /**
  * Test-only reset. Tears down any active shard entries (without running
  * deactivate hooks — tests should run deactivate explicitly if they care)

package/dist/shards/types.d.ts

@@ -1,7 +1,9 @@
 import type { StateZones } from '../state/zones.svelte';
 import type { ZoneSchema, ZoneManager } from '../state/types';
 import type { DocumentHandle, DocumentHandleOptions } from '../documents/types';
+import type { BrowseCapability } from '../documents/browse';
 import type { SyncHandle } from '../documents/sync/types';
+import type { SyncRegistry } from '../documents/sync/registry';
 import type { EnvState } from '../env/types';
 import type { Verb } from '../verbs/types';
 /**
@@ -83,6 +85,14 @@ export interface ViewDeclaration {
     label: string;
     /** Optional icon hint (reserved; not yet rendered in phase 8). */
     icon?: string;
+    /**
+     * When true, this view is a standalone primitive — summonable from
+     * anywhere without requiring an owning app. Standalone views are
+     * enumerable via the framework's view directory and can be popped
+     * out into a float or docked into the active layout by verbs like
+     * `popout` and `dock`. Defaults to false.
+     */
+    standalone?: boolean;
 }
 /**
  * Static description of a shard as observed by the framework and consumers
@@ -120,6 +130,8 @@ export interface ShardManifest {
      * Currently recognized:
      *   - 'state:manage' — cross-shard zone access.
      *   - 'documents:sync' — cross-shard document sync API.
+     *   - 'documents:browse' — tenant-wide document observation and sync
+     *     registry visibility (observer-class shards, e.g. file-explorer).
      */
     permissions?: string[];
 }
@@ -188,6 +200,12 @@ export interface ShardContext {
     envUpdate<T extends Record<string, unknown>>(patch: Partial<T>): Promise<void>;
     /** Whether the current session has admin privileges. */
     isAdmin: boolean;
+    /**
+     * The active tenant id. Always present. Exposed for logging / diagnostics.
+     * Scopes never carry tenantId; the engine rebinds per-session. Do not
+     * serialize into persistent storage.
+     */
+    tenantId: string;
     /**
      * Cross-shard zone management API. Only present when the shard's
      * manifest declares the `'state:manage'` permission. Check with
@@ -200,6 +218,21 @@ export interface ShardContext {
      * `if (ctx.sync)` before use.
      */
     sync?: () => SyncHandle;
+    /**
+     * Tenant-wide document browse API. Read-only enumeration and change
+     * subscription across every shard's documents for the active tenant.
+     * Only present when the shard's manifest declares the
+     * `'documents:browse'` permission. Writes still flow through the
+     * owning shard's own `ctx.documents()` handle.
+     */
+    browse?: BrowseCapability;
+    /**
+     * Sync registry observer. Read-only list/revoke/conflict enumeration
+     * for explorer-class shards. Only present when the shard declares
+     * `'documents:browse'`. Granting still happens exclusively via
+     * `<SyncGrantPicker />`.
+     */
+    syncRegistry?: () => SyncRegistry;
 }
 /**
  * A shard module. Shards are the fundamental unit of contribution in SH3.

package/dist/shell-shard/manifest.js

@@ -3,7 +3,7 @@ export const manifest = {
     id: 'shell',
     label: 'Shell',
     version: VERSION,
-    views: [{ id: 'shell:terminal', label: 'Shell' }],
+    views: [{ id: 'shell:terminal', label: 'Shell', standalone: true }],
     // serverBundle intentionally omitted — this shard is a framework built-in
     // and is statically mounted at sh3-server boot. The existing contract in
     // sh3-core/src/shards/types.ts documents that framework-shipped shards do

package/dist/shell-shard/shellShard.svelte.js

@@ -19,7 +19,9 @@ import { registerV1Verbs } from './verbs';
 import { listRegisteredApps, getActiveApp } from '../apps/registry.svelte';
 import { launchApp } from '../apps/lifecycle';
 import { registeredShards } from '../shards/activate.svelte';
-import { inspectActiveLayout, focusView, closeTab } from '../layout/inspection';
+import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIntoActiveLayout } from '../layout/inspection';
+import { floatManager } from '../overlays/float';
+import { listStandaloneViews } from '../shards/activate.svelte';
 import { getUser, isAdmin } from '../auth/index';
 /** Walk a layout tree and collect all tab entries (slotId + viewId + label). */
 function collectTabEntries(node) {
@@ -76,16 +78,62 @@ function makeShellApi(_ctx) {
                 return [];
             }
         },
-        // → layout/inspection: focusView(viewId) returns boolean
+        // → layout/inspection: focusView(viewId). Falls back to dockIntoActiveLayout
+        // for standalone views that aren't mounted yet — this is the single
+        // "summon" entry point wired behind the `open` verb.
         openViewInCurrentLayout(viewId) {
             try {
-                const found = focusView(viewId);
-                return found ? { ok: true } : { ok: false, error: `view "${viewId}" not found in current layout` };
+                if (focusView(viewId))
+                    return { ok: true };
+                const standalone = listStandaloneViews().find((v) => v.viewId === viewId);
+                if (standalone) {
+                    const slotId = `standalone:${viewId}:${Date.now()}`;
+                    const ok = dockIntoActiveLayout({ slotId, viewId, label: standalone.label });
+                    return ok ? { ok: true } : { ok: false, error: `could not dock "${viewId}" — no available slot` };
+                }
+                return { ok: false, error: `view "${viewId}" not found in current layout` };
             }
             catch (err) {
                 return { ok: false, error: err instanceof Error ? err.message : String(err) };
             }
         },
+        // → shards/activate.svelte: listStandaloneViews() walks activeShards
+        listStandaloneViews() {
+            return listStandaloneViews();
+        },
+        // → layout/inspection: popoutView(slotId) returns floatId | null
+        popoutSlot(slotId) {
+            try {
+                const floatId = popoutView(slotId);
+                return floatId ? { ok: true, floatId } : { ok: false, error: `slot "${slotId}" not found in docked tree` };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        // → layout/inspection: dockFloat(floatId) returns boolean
+        dockFloat(floatId) {
+            try {
+                const ok = dockFloat(floatId);
+                return ok ? { ok: true } : { ok: false, error: `float "${floatId}" not found or has no dockable content` };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        // → overlays/float: floatManager.list() returns FloatEntry[]
+        listFloats() {
+            return floatManager.list().map((f) => {
+                var _a, _b, _c, _d, _e;
+                const tabs = f.content.type === 'tabs' ? f.content : null;
+                const active = tabs ? (_b = tabs.tabs[(_a = tabs.activeTab) !== null && _a !== void 0 ? _a : 0]) !== null && _b !== void 0 ? _b : tabs.tabs[0] : null;
+                return {
+                    floatId: f.id,
+                    viewId: (_c = active === null || active === void 0 ? void 0 : active.viewId) !== null && _c !== void 0 ? _c : null,
+                    label: (_e = (_d = f.title) !== null && _d !== void 0 ? _d : active === null || active === void 0 ? void 0 : active.label) !== null && _e !== void 0 ? _e : f.id,
+                };
+            });
+        },
         // → layout/inspection: closeTab(slotId) is async (guarded close).
         // Fire-and-forget; the tab disappears asynchronously. ShellApi stays sync.
         closeSlot(slotId) {

package/dist/shell-shard/verbs/index.js

@@ -7,7 +7,7 @@ import { clearVerb } from './clear';
 import { historyVerb } from './history';
 import { appsVerb, appVerb } from './apps';
 import { shardsVerb } from './shards';
-import { viewsVerb, openVerb, closeVerb } from './views';
+import { viewsVerb, openVerb, closeVerb, popoutVerb, dockVerb } from './views';
 import { zonesVerb, zoneVerb } from './zones';
 import { pwdVerb, cdVerb, whoamiVerb } from './session';
 import { envVerb } from './env';
@@ -23,6 +23,8 @@ export function registerV1Verbs(ctx) {
     ctx.registerVerb(viewsVerb);
     ctx.registerVerb(openVerb);
     ctx.registerVerb(closeVerb);
+    ctx.registerVerb(popoutVerb);
+    ctx.registerVerb(dockVerb);
     ctx.registerVerb(zonesVerb);
     ctx.registerVerb(zoneVerb);
     ctx.registerVerb(pwdVerb);

package/dist/shell-shard/verbs/views.d.ts

@@ -1,4 +1,6 @@
 import type { Verb } from '../../verbs/types';
 export declare const viewsVerb: Verb;
 export declare const openVerb: Verb;
+export declare const popoutVerb: Verb;
+export declare const dockVerb: Verb;
 export declare const closeVerb: Verb;

package/dist/shell-shard/verbs/views.js

@@ -1,8 +1,29 @@
 import ViewsTable from '../rich/ViewsTable.svelte';
 export const viewsVerb = {
     name: 'views',
-    summary: 'List views currently mounted in the active layout.',
-    async run(ctx) {
+    summary: 'List views currently mounted. Pass --standalone to list summonable views instead.',
+    async run(ctx, args) {
+        if (args.includes('--standalone')) {
+            const standalones = ctx.shell.listStandaloneViews();
+            if (standalones.length === 0) {
+                ctx.scrollback.push({
+                    kind: 'status',
+                    text: 'shell: no standalone views are currently available.',
+                    level: 'info',
+                    ts: Date.now(),
+                });
+                return;
+            }
+            ctx.scrollback.push({
+                kind: 'status',
+                text: standalones
+                    .map((v) => `  ${v.viewId.padEnd(32)} ${v.label}`)
+                    .join('\n'),
+                level: 'info',
+                ts: Date.now(),
+            });
+            return;
+        }
         const views = ctx.shell.listViewsInCurrentLayout();
         ctx.scrollback.push({
             kind: 'rich',
@@ -62,6 +83,86 @@ export const openVerb = {
         }
     },
 };
+export const popoutVerb = {
+    name: 'popout',
+    summary: 'Pop a docked view out into a float by slot id.',
+    async run(ctx, args) {
+        var _a;
+        const slotId = args[0];
+        if (!slotId) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: 'usage: popout <slotId>',
+                level: 'warn',
+                ts: Date.now(),
+            });
+            return;
+        }
+        const result = ctx.shell.popoutSlot(slotId);
+        if (!result.ok) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: `shell: popout failed — ${(_a = result.error) !== null && _a !== void 0 ? _a : 'unknown'}`,
+                level: 'error',
+                ts: Date.now(),
+            });
+        }
+        else {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: `shell: popped out ${slotId} → ${result.floatId}`,
+                level: 'info',
+                ts: Date.now(),
+            });
+        }
+    },
+};
+export const dockVerb = {
+    name: 'dock',
+    summary: 'Dock a float back into the current layout by float id. Run with no args to list floats.',
+    async run(ctx, args) {
+        var _a;
+        const floatId = args[0];
+        if (!floatId) {
+            const floats = ctx.shell.listFloats();
+            if (floats.length === 0) {
+                ctx.scrollback.push({
+                    kind: 'status',
+                    text: 'shell: no active floats.',
+                    level: 'info',
+                    ts: Date.now(),
+                });
+                return;
+            }
+            ctx.scrollback.push({
+                kind: 'status',
+                text: floats
+                    .map((f) => { var _a; return `  ${f.floatId.padEnd(24)} ${(_a = f.viewId) !== null && _a !== void 0 ? _a : '-'}\t${f.label}`; })
+                    .join('\n'),
+                level: 'info',
+                ts: Date.now(),
+            });
+            return;
+        }
+        const result = ctx.shell.dockFloat(floatId);
+        if (!result.ok) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: `shell: dock failed — ${(_a = result.error) !== null && _a !== void 0 ? _a : 'unknown'}`,
+                level: 'error',
+                ts: Date.now(),
+            });
+        }
+        else {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: `shell: docked ${floatId}`,
+                level: 'info',
+                ts: Date.now(),
+            });
+        }
+    },
+};
 export const closeVerb = {
     name: 'close',
     summary: 'Close a view by slot id.',

package/dist/verbs/types.d.ts

@@ -29,6 +29,25 @@ export interface ShellApi {
         ok: boolean;
         error?: string;
     };
+    listStandaloneViews(): Array<{
+        shardId: string;
+        viewId: string;
+        label: string;
+    }>;
+    popoutSlot(slotId: string): {
+        ok: boolean;
+        error?: string;
+        floatId?: string;
+    };
+    dockFloat(floatId: string): {
+        ok: boolean;
+        error?: string;
+    };
+    listFloats(): Array<{
+        floatId: string;
+        viewId: string | null;
+        label: string;
+    }>;
     listZones(shardId?: string): Array<{
         shardId: string;
         zones: string[];

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

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