sh3-core 0.7.5 → 0.8.1

package/dist/registry/register.js

@@ -0,0 +1,22 @@
+/**
+ * Unified bundle registration — stamps loader-assigned metadata onto every
+ * shard/app manifest from a loaded bundle, then registers each. Shared by
+ * `installer.installPackage`, `installer.loadInstalledPackages`, and
+ * `createShell` discoveredPackages so the three boot paths stay in sync.
+ *
+ * Per ADR-013, external package authors omit `version` from their source
+ * manifests; the authoritative value comes from the persisted/server
+ * metadata and must be stamped here before any consumer reads the manifest.
+ */
+import { registerShard } from '../shards/activate.svelte';
+import { registerApp } from '../apps/registry.svelte';
+export function registerLoadedBundle(loaded, meta) {
+    for (const shard of loaded.shards) {
+        shard.manifest = Object.assign(Object.assign({}, shard.manifest), { version: meta.version });
+        registerShard(shard);
+    }
+    for (const app of loaded.apps) {
+        app.manifest = Object.assign(Object.assign({}, app.manifest), { version: meta.version });
+        registerApp(app);
+    }
+}

package/dist/registry/register.test.d.ts

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

package/dist/registry/register.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { resetFramework } from '../__test__/reset';
+import { makeApp, makeAppManifest, makeShard, makeShardManifest } from '../__test__/fixtures';
+import { registerLoadedBundle } from './register';
+import { registeredApps } from '../apps/registry.svelte';
+import { registeredShards } from '../shards/activate.svelte';
+describe('registerLoadedBundle', () => {
+    beforeEach(resetFramework);
+    it('stamps meta.version onto every shard manifest before registering', () => {
+        var _a;
+        const shard = makeShard({ manifest: makeShardManifest({ id: 'shard-1', version: '' }) });
+        registerLoadedBundle({ shards: [shard], apps: [] }, { version: '2.3.4', sourceRegistry: 'https://r', contractVersion: '1' });
+        expect((_a = registeredShards.get('shard-1')) === null || _a === void 0 ? void 0 : _a.manifest.version).toBe('2.3.4');
+    });
+    it('stamps meta.version onto every app manifest before registering', () => {
+        var _a;
+        const app = makeApp({ manifest: makeAppManifest({ id: 'app-1', version: '' }) });
+        registerLoadedBundle({ shards: [], apps: [app] }, { version: '2.3.4', sourceRegistry: 'https://r', contractVersion: '1' });
+        expect((_a = registeredApps.get('app-1')) === null || _a === void 0 ? void 0 : _a.manifest.version).toBe('2.3.4');
+    });
+    it('registers combo bundles (both shards and apps)', () => {
+        const shard = makeShard({ manifest: makeShardManifest({ id: 'combo-s' }) });
+        const app = makeApp({ manifest: makeAppManifest({ id: 'combo-a', requiredShards: ['combo-s'] }) });
+        registerLoadedBundle({ shards: [shard], apps: [app] }, { version: '1.0.0', sourceRegistry: '', contractVersion: '1' });
+        expect(registeredShards.has('combo-s')).toBe(true);
+        expect(registeredApps.has('combo-a')).toBe(true);
+    });
+});

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

@@ -23,6 +23,12 @@ import { fetchEnvState, putEnvState } from '../env/client';
 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
@@ -65,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;
+    var _a, _b, _c, _d, _e;
     const shard = registeredShards.get(id);
     if (!shard) {
         throw new Error(`Cannot activate shard "${id}": not registered`);
@@ -125,9 +131,36 @@ 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,
+        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();
+                const bundlePromise = getSyncBundle(backend, tenantId);
+                const handlePromise = bundlePromise.then(({ engine, registry }) => createSyncHandle({ tenantId, connectorId: id, engine, registry }));
+                return {
+                    connectorId: id,
+                    grantedScopes: async () => (await handlePromise).grantedScopes(),
+                    getManifest: async (scope) => (await handlePromise).getManifest(scope),
+                    changesSince: async (scope, cursor) => (await handlePromise).changesSince(scope, cursor),
+                    ack: async (scope, cursor) => (await handlePromise).ack(scope, cursor),
+                    apply: async (scope, entry, opts) => (await handlePromise).apply(scope, entry, opts),
+                    applyBatch: async (scope, manifest, opts) => (await handlePromise).applyBatch(scope, manifest, opts),
+                    forget: async (scope, path) => (await handlePromise).forget(scope, path),
+                };
+            }
+            : undefined,
     };
     entry.ctx = ctx;
     active.set(id, entry);
@@ -149,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 ((_b = shard.autostart) === null || _b === void 0 ? void 0 : _b.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
@@ -191,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,6 +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';
 /**
@@ -82,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
@@ -116,7 +127,11 @@ export interface ShardManifest {
     /**
      * Optional permissions this shard requests beyond the default sandbox.
      * Declared in the manifest and surfaced to the user at install time.
-     * Currently recognized: `'state:manage'` — cross-shard zone access.
+     * 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[];
 }
@@ -185,12 +200,39 @@ 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
      * `if (ctx.zones)` before use.
      */
     zones?: ZoneManager;
+    /**
+     * Cross-shard document sync API. Only present when the shard's
+     * manifest declares the `'documents:sync'` permission. Check with
+     * `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/Terminal.svelte

@@ -6,55 +6,149 @@
   import { SessionClient } from './session-client.svelte';
   import { VerbRegistry, type ShellApi } from './registry';
   import type { ServerMessage } from './protocol';
+  import { TenantFsClient } from './tenant-fs-client';
+  import { ShellModeRegistry } from './modes/registry';
+  import { registerBuiltinModes } from './modes/builtin';
+  import { resolveInitialMode, writeLastMode } from './modes/prefs';
+  import type { ShellMode, ShellRole } from './modes/types';
+  import { makeDispatch } from './dispatch';
+  import { computeRelocate } from './auto-relocate';
+  import { activeLayout } from '../layout/store.svelte';
+  import type { LayoutNode } from '../layout/types';
+  import Toolbar from './toolbar/Toolbar.svelte';
+  import { ToolbarSlotRegistry } from './toolbar/slots';
+  import ModeSlot from './toolbar/slots/ModeSlot.svelte';
+  import FocusLockSlot from './toolbar/slots/FocusLockSlot.svelte';
+  import TargetShardSlot from './toolbar/slots/TargetShardSlot.svelte';
 
   interface Props {
     shell: ShellApi;
     wsUrl: string;
+    userId: string;
+    role: ShellRole;
   }
-  let { shell, wsUrl }: Props = $props();
+  let { shell, wsUrl, userId, role }: Props = $props();
 
   const scrollback = new Scrollback();
+  const resolver = new VerbRegistry();
+  const fs = new TenantFsClient();
+
+  // Mode registry
+  const modeRegistry = new ShellModeRegistry();
+  registerBuiltinModes(modeRegistry);
+
+  // Reactive current mode
+  let mode = $state<ShellMode>(
+    untrack(() => resolveInitialMode(modeRegistry, userId, role)),
+  );
+
+  function setMode(id: string): void {
+    const next = modeRegistry.get(id);
+    if (!next) return;
+    if (next.requiresRole && next.requiresRole !== role) return;
+    mode = next;
+    writeLastMode(userId, id);
+    if (next.transport !== 'ws') {
+      scrollback.push({ kind: 'status', text: 'mode switch: reload to take effect for server-shell changes', level: 'info', ts: Date.now() });
+    }
+  }
+
   // wsUrl is a prop read at construction only. untrack prevents Svelte 5's
   // "referenced outside a closure" warning; the URL never changes at runtime.
   const session = untrack(() => new SessionClient(wsUrl));
-  const resolver = new VerbRegistry();
+
+  const dispatch = untrack(() => makeDispatch({
+    mode: () => mode,
+    resolver,
+    scrollback,
+    session,
+    shell,
+    fs,
+    cwd: () => session.cwd,
+  }));
 
   let locked = $state(false);
 
-  async function dispatch(line: string): Promise<void> {
-    session.history.push(line);
-    const resolution = resolver.resolve(line);
-    if (resolution.kind === 'local') {
-      // Log locally-dispatched verbs for shared history
-      session.send({ t: 'history-log', line });
-      scrollback.push({
-        kind: 'prompt',
-        cwd: session.cwd,
-        line,
-        ts: Date.now(),
-      });
-      try {
-        await resolution.verb.run({
-          shell,
-          scrollback,
-          session,
-          cwd: session.cwd,
-          dispatch,
-        }, resolution.args);
-      } catch (err) {
-        scrollback.push({
-          kind: 'status',
-          text: `shell: verb ${resolution.verb.name} threw — ${(err as Error).message}`,
-          level: 'error',
-          ts: Date.now(),
-        });
+  // ---------------------------------------------------------------------------
+  // Auto-relocate: track the focused shard and update session.cwd when focus
+  // changes to a shard whose documents directory exists. focusLocked and
+  // targetShard are read by Task 13's toolbar component via props.
+  // ---------------------------------------------------------------------------
+
+  let focusLocked = $state(false);
+  let targetShard = $state<string | null>(null);
+
+  function toggleFocusLock(): void {
+    focusLocked = !focusLocked;
+  }
+
+  // Toolbar slot registry
+  const toolbarRegistry = new ToolbarSlotRegistry();
+  toolbarRegistry.register({ id: 'mode', order: 10, visible: () => true, component: ModeSlot });
+  toolbarRegistry.register({ id: 'focus-lock', order: 20, visible: (ctx) => ctx.mode.id === 'user', component: FocusLockSlot });
+  toolbarRegistry.register({ id: 'target-shard', order: 30, visible: (ctx) => ctx.mode.id === 'user', component: TargetShardSlot });
+
+  let toolbarExpanded = $state((() => {
+    try { return localStorage.getItem('sh3.shell.toolbarExpanded') !== '0'; } catch { return true; }
+  })());
+
+  function toggleToolbar() {
+    toolbarExpanded = !toolbarExpanded;
+    try { localStorage.setItem('sh3.shell.toolbarExpanded', toolbarExpanded ? '1' : '0'); } catch {}
+  }
+
+  /** Walk the layout tree and return the viewId of the active tab in the first
+   *  TabsNode found (breadth-first). Returns null if the layout contains no
+   *  tabs node with a populated active tab. */
+  function getActiveViewId(node: LayoutNode): string | null {
+    if (node.type === 'tabs') {
+      const entry = node.tabs[node.activeTab];
+      return entry?.viewId ?? null;
+    }
+    if (node.type === 'split') {
+      for (const child of node.children) {
+        const found = getActiveViewId(child);
+        if (found !== null) return found;
       }
-    } else {
-      // Forward to server
-      session.send({ t: 'submit', line: resolution.line });
     }
+    // slot node
+    return node.viewId ?? null;
   }
 
+  /** Derive the focused shard id from the currently-active layout. The shard
+   *  id is the prefix before the first ':' in a viewId (e.g. 'shell:terminal'
+   *  → 'shell'). Returns null when no view is active. */
+  function getFocusedShardId(): string | null {
+    try {
+      const tree = activeLayout();
+      const viewId = getActiveViewId(tree.docked);
+      if (!viewId) return null;
+      const colon = viewId.indexOf(':');
+      return colon >= 0 ? viewId.slice(0, colon) : viewId;
+    } catch {
+      return null;
+    }
+  }
+
+  $effect(() => {
+    const focused = getFocusedShardId();
+    const autoRelocate = mode.autoRelocate;
+    const isFocusLocked = focusLocked;
+    (async () => {
+      const r = await computeRelocate({
+        modeAutoRelocate: autoRelocate,
+        focusLocked: isFocusLocked,
+        focusedShardId: focused,
+        currentShardId: 'shell',
+      }, fs);
+      if (r.kind === 'relocate' && r.path !== undefined) {
+        session.cwd = r.path;
+      }
+      if (focused && focused !== 'shell') targetShard = focused;
+      else if (!focused) targetShard = null;
+    })();
+  });
+
   function handleServerMessage(msg: ServerMessage) {
     if (msg.t !== 'event') return;
     const e = msg.event;
@@ -96,7 +190,9 @@
 
   onMount(() => {
     unsub = session.onMessage(handleServerMessage);
-    session.connect();
+    if (mode.transport === 'ws') {
+      session.connect();
+    }
   });
 
   onDestroy(() => {
@@ -106,6 +202,17 @@
 </script>
 
 <div class="shell-terminal">
+  <Toolbar
+    registry={toolbarRegistry}
+    ctx={{ mode, role }}
+    expanded={toolbarExpanded}
+    onToggle={toggleToolbar}
+    slotProps={{
+      mode: { mode, role, registry: modeRegistry, onSelect: setMode },
+      'focus-lock': { locked: focusLocked, onToggle: () => (focusLocked = !focusLocked) },
+      'target-shard': { target: targetShard },
+    }}
+  />
   <ScrollbackView {scrollback} />
   <InputLine
     cwd={session.cwd}

package/dist/shell-shard/Terminal.svelte.d.ts

@@ -1,7 +1,10 @@
 import { type ShellApi } from './registry';
+import type { ShellRole } from './modes/types';
 interface Props {
     shell: ShellApi;
     wsUrl: string;
+    userId: string;
+    role: ShellRole;
 }
 declare const Terminal: import("svelte").Component<Props, {}, "">;
 type Terminal = ReturnType<typeof Terminal>;

package/dist/shell-shard/auto-relocate.d.ts

@@ -0,0 +1,12 @@
+import type { TenantFsClient } from './tenant-fs-client';
+export interface RelocateInput {
+    modeAutoRelocate: boolean;
+    focusLocked: boolean;
+    focusedShardId: string | null;
+    currentShardId: string;
+}
+export interface RelocateEffect {
+    kind: 'noop' | 'relocate';
+    path?: string;
+}
+export declare function computeRelocate(input: RelocateInput, fs: TenantFsClient): Promise<RelocateEffect>;

package/dist/shell-shard/auto-relocate.js

@@ -0,0 +1,20 @@
+export async function computeRelocate(input, fs) {
+    if (!input.modeAutoRelocate)
+        return { kind: 'noop' };
+    if (input.focusLocked)
+        return { kind: 'noop' };
+    if (input.focusedShardId === null)
+        return { kind: 'noop' };
+    if (input.focusedShardId === input.currentShardId)
+        return { kind: 'noop' };
+    const path = input.focusedShardId;
+    try {
+        const s = await fs.stat(path);
+        if (s.kind !== 'dir')
+            return { kind: 'noop' };
+    }
+    catch (_a) {
+        return { kind: 'noop' };
+    }
+    return { kind: 'relocate', path };
+}

package/dist/shell-shard/auto-relocate.test.d.ts

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

package/dist/shell-shard/auto-relocate.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from 'vitest';
+import { computeRelocate } from './auto-relocate';
+const statOk = { list: vi.fn(), read: vi.fn(), stat: async () => ({ name: 'notes', kind: 'dir', size: 0, mtime: 0 }) };
+const statMissing = { list: vi.fn(), read: vi.fn(), stat: async () => { throw new Error('not found'); } };
+const statFile = { list: vi.fn(), read: vi.fn(), stat: async () => ({ name: 'notes', kind: 'file', size: 0, mtime: 0 }) };
+describe('computeRelocate', () => {
+    it('noop when mode disables auto-relocate', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: false, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when focus-lock is on', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: true, focusedShardId: 'notes', currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when nothing relevant is focused', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: null, currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when focusing the shell itself', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'shell', currentShardId: 'shell' }, statOk);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when target documents folder does not exist', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statMissing);
+        expect(r.kind).toBe('noop');
+    });
+    it('noop when target is a file, not a directory', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statFile);
+        expect(r.kind).toBe('noop');
+    });
+    it('relocates to the shard id path on happy path', async () => {
+        const r = await computeRelocate({ modeAutoRelocate: true, focusLocked: false, focusedShardId: 'notes', currentShardId: 'shell' }, statOk);
+        expect(r).toEqual({ kind: 'relocate', path: 'notes' });
+    });
+});