sh3-core 0.22.2 → 0.23.2

package/dist/shards/lifecycle.svelte.js

@@ -17,6 +17,7 @@ import { PERMISSION_STATE_MANAGE } from '../state/types';
 import { PERMISSION_DOCUMENTS_BROWSE, PERMISSION_DOCUMENTS_READ, PERMISSION_DOCUMENTS_WRITE, } from '../documents/types';
 import { createBrowseCapability } from '../documents/browse';
 import { createDocumentPicker } from '../documents/picker-primitive';
+import { documentChanges } from '../documents/notifications';
 import { createShardKeysApi } from '../keys/client';
 import { PERMISSION_KEYS_MINT } from '../keys/types';
 import { makeSh3Api } from '../sh3Api/headless';
@@ -29,11 +30,65 @@ import { clearSelectionForShard } from '../actions/selection.svelte';
 import { fetchEnvState } from '../env/client';
 import { subscribe as subscribeKeyRevocation } from '../keys/revocation-bus.svelte';
 const shardAppBindings = $state(new Map());
+/**
+ * Build the picker-primitive options for a shard: backend-backed
+ * `listFolders` so empty folders surface in the modal, a mutation `handle`
+ * that emits the right documentChanges events, and a `readOnlyShard`
+ * predicate that blocks cross-shard mutations unless the caller holds
+ * `documents:write`.
+ */
+function makePickerOptions(callerShardId, permissions, lockToShard) {
+    const backend = getDocumentBackend();
+    const hasWrite = permissions.includes(PERMISSION_DOCUMENTS_WRITE);
+    return {
+        listFolders: (sid, prefix) => backend.listFolders(getActiveScopeId(), sid, prefix),
+        handle: {
+            mkdir: async (sid, path) => {
+                const tid = getActiveScopeId();
+                await backend.mkdir(tid, sid, path);
+                documentChanges.emit({ type: 'folder-create', path, tenantId: tid, shardId: sid });
+            },
+            rmdir: async (sid, path, opts) => {
+                const tid = getActiveScopeId();
+                await backend.rmdir(tid, sid, path, opts);
+                documentChanges.emit({ type: 'folder-delete', path, tenantId: tid, shardId: sid });
+            },
+            renameFolder: async (sid, oldPath, newPath) => {
+                const tid = getActiveScopeId();
+                await backend.renameFolder(tid, sid, oldPath, newPath);
+                documentChanges.emit({ type: 'folder-rename', path: newPath, oldPath, tenantId: tid, shardId: sid });
+            },
+            rename: async (sid, oldPath, newPath) => {
+                const tid = getActiveScopeId();
+                await backend.rename(tid, sid, oldPath, newPath);
+                documentChanges.emit({ type: 'rename', path: newPath, oldPath, tenantId: tid, shardId: sid });
+            },
+            delete: async (sid, path) => {
+                const tid = getActiveScopeId();
+                const existed = await backend.exists(tid, sid, path);
+                await backend.delete(tid, sid, path);
+                if (existed)
+                    documentChanges.emit({ type: 'delete', path, tenantId: tid, shardId: sid });
+            },
+        },
+        readOnlyShard: (sid) => sid !== callerShardId && !hasWrite,
+        initialShardId: callerShardId,
+        lockToShard,
+    };
+}
 /**
  * Reactive registry of every shard known to the host. Keys are shard ids.
  * Populated by `registerShard`.
  */
 export const registeredShards = $state(new Map());
+/**
+ * Reactive snapshot of every registered shard's manifest. Mirrors
+ * `listRegisteredApps()` — used by project manage UI / ShardPicker to
+ * enumerate service-kind shards.
+ */
+export function listRegisteredShards() {
+    return Array.from(registeredShards.values()).map((s) => s.manifest);
+}
 export const erroredShards = $state(new Map());
 /** Read the app id currently bound to this shard, or null. */
 export function getShardBinding(shardId) {
@@ -65,7 +120,7 @@ export function __setScopeResolver(resolver) {
  * `entry.activeAppId`); otherwise they go to the boot bag.
  */
 export function buildShardContext(shard, entry) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     const id = shard.manifest.id;
     function trackDisposer(fn) {
         var _a;
@@ -200,15 +255,15 @@ export function buildShardContext(shard, entry) {
             : undefined,
         browse: browseCap,
         documentPicker: browseCap
-            ? createDocumentPicker(() => browseCap.listDocuments())
+            ? createDocumentPicker(() => browseCap.listDocuments(), makePickerOptions(id, (_g = shard.manifest.permissions) !== null && _g !== void 0 ? _g : [], false))
             : createDocumentPicker(async () => {
                 const docs = await getDocumentBackend().list(getActiveScopeId(), id);
                 return docs.map(d => (Object.assign(Object.assign({}, d), { shardId: id })));
-            }),
-        keys: ((_g = shard.manifest.permissions) === null || _g === void 0 ? void 0 : _g.includes(PERMISSION_KEYS_MINT))
+            }, makePickerOptions(id, (_h = shard.manifest.permissions) !== null && _h !== void 0 ? _h : [], true)),
+        keys: ((_j = shard.manifest.permissions) === null || _j === void 0 ? void 0 : _j.includes(PERMISSION_KEYS_MINT))
             ? createShardKeysApi({
                 shardId: id,
-                shardPermissions: (_h = shard.manifest.permissions) !== null && _h !== void 0 ? _h : [],
+                shardPermissions: (_k = shard.manifest.permissions) !== null && _k !== void 0 ? _k : [],
             })
             : undefined,
         contributions,
@@ -225,9 +280,10 @@ export function buildShardContext(shard, entry) {
         sh3: makeSh3Api({
             callerKind: 'shard',
             callerShardId: id,
-            zones: ((_j = shard.manifest.permissions) === null || _j === void 0 ? void 0 : _j.includes(PERMISSION_STATE_MANAGE))
+            zones: ((_l = shard.manifest.permissions) === null || _l === void 0 ? void 0 : _l.includes(PERMISSION_STATE_MANAGE))
                 ? createZoneManager()
                 : undefined,
+            docs: browseCap,
         }),
     };
     // Stash env state on the ctx for registerAllShards' hydration step.
@@ -241,10 +297,12 @@ export const activeShards = $state(new Map());
  * an already-entered shard is a no-op. Errors are recorded in
  * `erroredShards` with phase 'register'; one failure does not block others.
  */
-export async function registerAllShards() {
+export async function registerAllShards(allowed = null) {
     for (const [id, shard] of registeredShards) {
         if (shardEntries.has(id))
             continue;
+        if (allowed !== null && !allowed.has(id))
+            continue;
         const entry = {
             shard,
             ctx: undefined,

package/dist/shards/lifecycle.test.js

@@ -1,6 +1,14 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { getShardBinding, rotateShardDocumentNamespace, __resetLifecycleForTest, registerAllShards, runAppActivate, runAppDeactivate, rebuildShardEntry, shardEntries, } from './lifecycle.svelte';
+import { __setActiveScope, __setDocumentBackend } from '../documents/config';
+import { MemoryDocumentBackend } from '../documents/backends';
+import { getShardBinding, rotateShardDocumentNamespace, __resetLifecycleForTest, registerAllShards, runAppActivate, runAppDeactivate, rebuildShardEntry, shardEntries, listRegisteredShards, } from './lifecycle.svelte';
 import { registerShard, __resetShardRegistryForTest, erroredShards } from './lifecycle.svelte';
+function makeShard(id, registerFn) {
+    return {
+        manifest: { id, label: id, version: '0.0.0', views: [] },
+        register: registerFn,
+    };
+}
 describe('shards/lifecycle — binding map', () => {
     beforeEach(() => __resetLifecycleForTest());
     it('returns null for an unbound shard', () => {
@@ -137,3 +145,104 @@ describe('hot-swap on re-register', () => {
         expect((_c = shardEntries.get('hot-s')) === null || _c === void 0 ? void 0 : _c.shard.manifest.version).toBe('0.0.1');
     });
 });
+describe('registerAllShards with allowed-set gate', () => {
+    beforeEach(() => {
+        __resetLifecycleForTest();
+        __resetShardRegistryForTest();
+    });
+    it('skips shards not in the allowed set when one is provided', async () => {
+        const calls = [];
+        const a = makeShard('shard-a', () => { calls.push('a'); });
+        const b = makeShard('shard-b', () => { calls.push('b'); });
+        const c = makeShard('shard-c', () => { calls.push('c'); });
+        registerShard(a);
+        registerShard(b);
+        registerShard(c);
+        await registerAllShards(new Set(['shard-a', 'shard-c']));
+        expect(calls).toEqual(['a', 'c']);
+        expect(shardEntries.has('shard-a')).toBe(true);
+        expect(shardEntries.has('shard-b')).toBe(false);
+        expect(shardEntries.has('shard-c')).toBe(true);
+    });
+    it('registers everything when allowed-set is null', async () => {
+        const calls = [];
+        const a = makeShard('shard-a', () => { calls.push('a'); });
+        const b = makeShard('shard-b', () => { calls.push('b'); });
+        registerShard(a);
+        registerShard(b);
+        await registerAllShards(null);
+        expect(calls).toEqual(['a', 'b']);
+    });
+    it('registers everything when allowed-set arg is omitted (back-compat)', async () => {
+        const calls = [];
+        const a = makeShard('shard-a', () => { calls.push('a'); });
+        registerShard(a);
+        await registerAllShards();
+        expect(calls).toEqual(['a']);
+    });
+});
+describe('listRegisteredShards', () => {
+    beforeEach(() => {
+        __resetLifecycleForTest();
+        __resetShardRegistryForTest();
+    });
+    it('returns the manifest of every registered shard', () => {
+        var _a;
+        const a = {
+            manifest: { id: 'a', label: 'A', version: '1.0.0', views: [] },
+            register: () => { },
+        };
+        const b = {
+            manifest: { id: 'b', label: 'B', version: '1.0.0', views: [], kind: 'service' },
+            register: () => { },
+        };
+        registerShard(a);
+        registerShard(b);
+        const manifests = listRegisteredShards();
+        expect(manifests.map((m) => m.id).sort()).toEqual(['a', 'b']);
+        expect((_a = manifests.find((m) => m.id === 'b')) === null || _a === void 0 ? void 0 : _a.kind).toBe('service');
+    });
+});
+describe('shards/lifecycle — ctx.sh3.docs wiring', () => {
+    beforeEach(() => {
+        __resetLifecycleForTest();
+        __resetShardRegistryForTest();
+        __setDocumentBackend(new MemoryDocumentBackend());
+        __setActiveScope('tenant-test');
+    });
+    it('mirrors ctx.browse onto ctx.sh3.docs for browse-permitted shards', async () => {
+        let captured = { sh3Docs: 'untouched', ctxBrowse: 'untouched' };
+        const shard = {
+            manifest: {
+                id: 'browse-test',
+                label: 'Browse Test',
+                version: '0.0.1',
+                views: [],
+                permissions: ['documents:browse', 'documents:read', 'documents:write'],
+            },
+            register(ctx) {
+                captured = { sh3Docs: ctx.sh3.docs, ctxBrowse: ctx.browse };
+            },
+        };
+        registerShard(shard);
+        await registerAllShards();
+        expect(captured.sh3Docs).toBeDefined();
+        expect(captured.sh3Docs).toBe(captured.ctxBrowse);
+    });
+    it('leaves ctx.sh3.docs undefined when shard lacks documents:browse', async () => {
+        let docsRef = 'untouched';
+        const shard = {
+            manifest: {
+                id: 'no-browse-test',
+                label: 'No Browse',
+                version: '0.0.1',
+                views: [],
+                permissions: [],
+            },
+            register(ctx) { docsRef = ctx.sh3.docs; },
+        };
+        registerShard(shard);
+        await registerAllShards();
+        expect(docsRef).toBeUndefined();
+    });
+});

package/dist/shards/types.d.ts

@@ -176,6 +176,19 @@ export interface ShardManifest {
      * by sh3-validate at build time.
      */
     verbNamespace?: string;
+    /**
+     * Project-allowlist classification.
+     *   - 'system'  : always allowed in every project scope. The shard is part
+     *                 of the framework/OS surface (e.g. shell-shard). Surfaced
+     *                 read-only in the project manage view.
+     *   - 'service' : opt-in per project. Appears in the Shards tab of the
+     *                 project manage view; admin ticks it to grant write access.
+     *   - omitted   : regular shard. Reached only via an app's
+     *                 requiredShards / bundledShards (existing behavior).
+     *
+     * Apps never set this — shard-only.
+     */
+    kind?: 'system' | 'service';
 }
 /**
  * Source-declared shape of a shard manifest — what external package authors

package/dist/shell-shard/Terminal.svelte

@@ -28,7 +28,6 @@
   import BusySlot from './toolbar/slots/BusySlot.svelte';
   import { registerTerminalView, mintTerminalId, type TerminalHandle } from './terminal-registry';
   import { makeDispatchToTerminal } from './dispatch-to-terminal';
-  import type { BrowseCapability } from '../documents/browse';
 
   interface Props {
     shell: Sh3Api;
@@ -36,9 +35,8 @@
     userId: string;
     role: ShellRole;
     contributions: ContributionsApi;
-    docs?: BrowseCapability;
   }
-  let { shell, wsUrl, userId, role, contributions, docs }: Props = $props();
+  let { shell, wsUrl, userId, role, contributions }: Props = $props();
 
   // Per-mode buffer map. Each ModeBuffer bundles a Scrollback + history +
   // locked flag and is materialized lazily on first switch into that mode.
@@ -252,7 +250,6 @@
     session,
     sh3: shellWithModes,
     fs,
-    docs,
     cwd: () => session.cwd,
     busy: acquireBusy,
     customMode: (id: string) => contributedModes.find((d) => d.id === id) ?? null,

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

@@ -1,14 +1,12 @@
 import { type Sh3Api } from './registry';
 import type { ShellRole } from './modes/types';
 import type { ContributionsApi } from '../contributions/types';
-import type { BrowseCapability } from '../documents/browse';
 interface Props {
     shell: Sh3Api;
     wsUrl: string;
     userId: string;
     role: ShellRole;
     contributions: ContributionsApi;
-    docs?: BrowseCapability;
 }
 declare const Terminal: import("svelte").Component<Props, {}, "">;
 type Terminal = ReturnType<typeof Terminal>;

package/dist/shell-shard/dispatch.d.ts

@@ -4,7 +4,6 @@ import type { TenantFsClient } from './tenant-fs-client';
 import type { ModeBuffer } from './mode-buffer.svelte';
 import type { ShellMode, ShellRole } from './modes/types';
 import type { ShellModeDescriptor } from './contract';
-import type { BrowseCapability } from '../documents/browse';
 export interface DispatchDeps {
     mode: () => ShellMode;
     /** Current shell role — used by invoke() role-gating. */
@@ -19,7 +18,6 @@ export interface DispatchDeps {
     session: SessionClient;
     sh3: Sh3Api;
     fs: TenantFsClient;
-    docs?: BrowseCapability;
     cwd: () => string;
     /**
      * Acquire a busy indicator. Returns a clear handle. Calling clear()

package/dist/shell-shard/dispatch.js

@@ -39,7 +39,6 @@ export function makeDispatch(deps) {
                 cwd: deps.cwd(),
                 dispatch,
                 fs: deps.fs,
-                docs: deps.docs,
             }, resolution.args);
             return;
         }
@@ -108,7 +107,6 @@ export function makeDispatch(deps) {
                     cwd: deps.cwd(),
                     dispatch,
                     fs: deps.fs,
-                    docs: deps.docs,
                 }, resolution.args);
             }
             catch (err) {

package/dist/shell-shard/display-cwd.test.js

@@ -2,19 +2,19 @@ import { describe, it, expect } from 'vitest';
 import { shortenCwd } from './display-cwd';
 describe('shortenCwd', () => {
     it('returns ~ when cwd equals tenant root', () => {
-        expect(shortenCwd('/home/u/data/users/x/documents/shell', '/home/u/data/users/x/documents/shell')).toBe('~');
+        expect(shortenCwd('/home/u/data/docs/x', '/home/u/data/docs/x')).toBe('~');
     });
     it('substitutes ~ for tenant-root prefix (POSIX)', () => {
-        expect(shortenCwd('/home/u/data/users/x/documents/shell/notes', '/home/u/data/users/x/documents/shell')).toBe('~/notes');
+        expect(shortenCwd('/home/u/data/docs/x/notes', '/home/u/data/docs/x')).toBe('~/notes');
     });
     it('substitutes ~ for tenant-root prefix (Windows)', () => {
-        expect(shortenCwd('C:\\a\\b\\users\\x\\documents\\shell\\notes', 'C:\\a\\b\\users\\x\\documents\\shell')).toBe('~/notes');
+        expect(shortenCwd('C:\\a\\b\\docs\\x\\notes', 'C:\\a\\b\\docs\\x')).toBe('~/notes');
     });
     it('normalizes Windows backslashes to forward slashes after the tilde', () => {
         expect(shortenCwd('C:\\root\\a\\b\\c', 'C:\\root')).toBe('~/a/b/c');
     });
     it('returns the absolute cwd when outside the tenant root', () => {
-        expect(shortenCwd('/tmp', '/home/u/data/users/x/documents/shell')).toBe('/tmp');
+        expect(shortenCwd('/tmp', '/home/u/data/docs/x')).toBe('/tmp');
     });
     it('does not match when cwd matches the tenant root prefix without a separator boundary', () => {
         // tenant=/foo, cwd=/foobar → must NOT shorten to ~bar

package/dist/shell-shard/manifest.js

@@ -5,6 +5,7 @@ export const manifest = {
     id: 'shell',
     label: 'Sh3',
     version: VERSION,
+    kind: 'system',
     views: [{ id: 'shell:terminal', label: 'Sh3', standalone: true }],
     // serverBundle intentionally omitted — this shard is a framework built-in
     // and is statically mounted at sh3-server boot. The existing contract in

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

@@ -1,3 +1,3 @@
 import type { Shard } from '../api';
-export { makeSh3ApiHeadless, makeSh3ApiForTest } from '../sh3Api/headless';
+export { makeSh3ApiForTest } from '../sh3Api/headless';
 export declare const shellShard: Shard;

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

@@ -20,18 +20,23 @@ import { mount, unmount } from 'svelte';
 import { manifest } from './manifest';
 import Terminal from './Terminal.svelte';
 import { registerV1Verbs } from './verbs';
-import { makeSh3ApiHeadless } from '../sh3Api/headless';
+import { makeSh3Api } from '../sh3Api/headless';
 import { focusView } from '../layout/inspection';
 import { floatManager } from '../overlays/float';
 import { getUser, isAdmin } from '../auth/index';
 import { __bindZone, __unbindZone } from './buffer-zone-state.svelte';
 import { getAuthToken } from '../transport/authToken';
-export { makeSh3ApiHeadless, makeSh3ApiForTest } from '../sh3Api/headless';
+export { makeSh3ApiForTest } from '../sh3Api/headless';
 export const shellShard = {
     manifest,
     register(ctx) {
         registerV1Verbs(ctx);
-        const shell = makeSh3ApiHeadless(ctx.zones);
+        const shell = makeSh3Api({
+            callerKind: 'shard',
+            callerShardId: 'shell',
+            zones: ctx.zones,
+            docs: ctx.browse,
+        });
         // Bind the shell-shard's workspace zone — backs scrollback persistence
         // (SH8). BufferStore reads/writes through this proxy.
         const zone = ctx.state({
@@ -73,7 +78,7 @@ export const shellShard = {
                 const role = isAdmin() ? 'admin' : 'user';
                 const instance = mount(Terminal, {
                     target: container,
-                    props: { shell, wsUrl, userId, role, contributions: ctx.contributions, docs: ctx.browse },
+                    props: { shell, wsUrl, userId, role, contributions: ctx.contributions },
                 });
                 return {
                     unmount() {

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

@@ -5,7 +5,7 @@ export const catVerb = {
     programmatic: true,
     async run(ctx, args) {
         const ts = Date.now();
-        if (!ctx.docs) {
+        if (!ctx.sh3.docs) {
             ctx.scrollback.push({ kind: 'status', text: 'cat: document capability not available', level: 'error', ts });
             return;
         }
@@ -18,11 +18,11 @@ export const catVerb = {
             ctx.scrollback.push({ kind: 'status', text: `cat: invalid path '${args[0]}'`, level: 'error', ts });
             return;
         }
-        if (!ctx.docs.readFrom) {
+        if (!ctx.sh3.docs.readFrom) {
             ctx.scrollback.push({ kind: 'status', text: 'cat: read permission not granted', level: 'error', ts });
             return;
         }
-        const content = await ctx.docs.readFrom(parsed.shardId, parsed.path);
+        const content = await ctx.sh3.docs.readFrom(parsed.shardId, parsed.path);
         if (content === null) {
             ctx.scrollback.push({ kind: 'status', text: `cat: not found: ${args[0]}`, level: 'error', ts });
             return;

package/dist/shell-shard/verbs/cat.test.js

@@ -6,12 +6,11 @@ function makeDocs(overrides = {}) {
 function makeCtx(docs) {
     const pushed = [];
     const ctx = {
-        sh3: {},
+        sh3: { docs },
         scrollback: { push: (e) => pushed.push(e) },
         session: {},
         cwd: '/',
         fs: {},
-        docs,
         dispatch: async () => { },
     };
     return { ctx, pushed };

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

@@ -6,11 +6,11 @@ export const lsVerb = {
     async run(ctx, args) {
         var _a, _b, _c;
         const ts = Date.now();
-        if (!ctx.docs) {
+        if (!ctx.sh3.docs) {
             ctx.scrollback.push({ kind: 'status', text: 'ls: document capability not available', level: 'error', ts });
             return;
         }
-        const all = await ctx.docs.listDocuments();
+        const all = await ctx.sh3.docs.listDocuments();
         const arg = args[0];
         if (!arg) {
             // Group by shard, emit counts

package/dist/shell-shard/verbs/ls.test.js

@@ -6,12 +6,11 @@ function makeDocs(overrides = {}) {
 function makeCtx(docs) {
     const pushed = [];
     const ctx = {
-        sh3: {},
+        sh3: { docs },
         scrollback: { push: (e) => pushed.push(e) },
         session: {},
         cwd: '/',
         fs: {},
-        docs,
         dispatch: async () => { },
     };
     return { ctx, pushed };

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

@@ -5,7 +5,7 @@ export const mkdirVerb = {
     programmatic: true,
     async run(ctx, args) {
         const ts = Date.now();
-        if (!ctx.docs) {
+        if (!ctx.sh3.docs) {
             ctx.scrollback.push({ kind: 'status', text: 'mkdir: document capability not available', level: 'error', ts });
             return;
         }
@@ -13,7 +13,7 @@ export const mkdirVerb = {
             ctx.scrollback.push({ kind: 'status', text: 'usage: mkdir <shardId>/<folder>', level: 'error', ts });
             return;
         }
-        if (!ctx.docs.writeTo) {
+        if (!ctx.sh3.docs.writeTo) {
             ctx.scrollback.push({ kind: 'status', text: 'mkdir: write permission not granted', level: 'error', ts });
             return;
         }
@@ -24,7 +24,7 @@ export const mkdirVerb = {
         }
         // Materialise the folder with a sentinel file; backends treat paths as flat.
         const keepPath = parsed.path.replace(/\/$/, '') + '/.keep';
-        await ctx.docs.writeTo(parsed.shardId, keepPath, '');
+        await ctx.sh3.docs.writeTo(parsed.shardId, keepPath, '');
         ctx.scrollback.push({ kind: 'status', text: `mkdir: created ${args[0]}`, level: 'info', ts });
     },
 };

package/dist/shell-shard/verbs/mkdir.test.js

@@ -6,12 +6,11 @@ function makeDocs(overrides = {}) {
 function makeCtx(docs) {
     const pushed = [];
     const ctx = {
-        sh3: {},
+        sh3: { docs },
         scrollback: { push: (e) => pushed.push(e) },
         session: {},
         cwd: '/',
         fs: {},
-        docs,
         dispatch: async () => { },
     };
     return { ctx, pushed };

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

@@ -5,7 +5,7 @@ export const mvVerb = {
     programmatic: true,
     async run(ctx, args) {
         const ts = Date.now();
-        if (!ctx.docs) {
+        if (!ctx.sh3.docs) {
             ctx.scrollback.push({ kind: 'status', text: 'mv: document capability not available', level: 'error', ts });
             return;
         }
@@ -13,7 +13,7 @@ export const mvVerb = {
             ctx.scrollback.push({ kind: 'status', text: 'usage: mv <shardId>/<old> <shardId>/<new>', level: 'error', ts });
             return;
         }
-        if (!ctx.docs.renameFrom) {
+        if (!ctx.sh3.docs.renameFrom) {
             ctx.scrollback.push({ kind: 'status', text: 'mv: write permission not granted', level: 'error', ts });
             return;
         }
@@ -27,7 +27,7 @@ export const mvVerb = {
             ctx.scrollback.push({ kind: 'status', text: 'mv: src and dst must be in the same shard (use xfer for cross-scope moves)', level: 'error', ts });
             return;
         }
-        await ctx.docs.renameFrom(src.shardId, src.path, dst.path);
+        await ctx.sh3.docs.renameFrom(src.shardId, src.path, dst.path);
         ctx.scrollback.push({ kind: 'status', text: `mv: renamed ${args[0]} → ${args[1]}`, level: 'info', ts });
     },
 };

package/dist/shell-shard/verbs/mv.test.js

@@ -6,12 +6,11 @@ function makeDocs(overrides = {}) {
 function makeCtx(docs) {
     const pushed = [];
     const ctx = {
-        sh3: {},
+        sh3: { docs },
         scrollback: { push: (e) => pushed.push(e) },
         session: {},
         cwd: '/',
         fs: {},
-        docs,
         dispatch: async () => { },
     };
     return { ctx, pushed };

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

@@ -5,7 +5,7 @@ export const rmVerb = {
     programmatic: true,
     async run(ctx, args) {
         const ts = Date.now();
-        if (!ctx.docs) {
+        if (!ctx.sh3.docs) {
             ctx.scrollback.push({ kind: 'status', text: 'rm: document capability not available', level: 'error', ts });
             return;
         }
@@ -13,7 +13,7 @@ export const rmVerb = {
             ctx.scrollback.push({ kind: 'status', text: 'usage: rm <shardId>/<path>', level: 'error', ts });
             return;
         }
-        if (!ctx.docs.deleteFrom) {
+        if (!ctx.sh3.docs.deleteFrom) {
             ctx.scrollback.push({ kind: 'status', text: 'rm: write permission not granted', level: 'error', ts });
             return;
         }
@@ -22,7 +22,7 @@ export const rmVerb = {
             ctx.scrollback.push({ kind: 'status', text: `rm: invalid path '${args[0]}'`, level: 'error', ts });
             return;
         }
-        await ctx.docs.deleteFrom(parsed.shardId, parsed.path);
+        await ctx.sh3.docs.deleteFrom(parsed.shardId, parsed.path);
         ctx.scrollback.push({ kind: 'status', text: `rm: deleted ${args[0]}`, level: 'info', ts });
     },
 };

package/dist/shell-shard/verbs/rm.test.js

@@ -6,12 +6,11 @@ function makeDocs(overrides = {}) {
 function makeCtx(docs) {
     const pushed = [];
     const ctx = {
-        sh3: {},
+        sh3: { docs },
         scrollback: { push: (e) => pushed.push(e) },
         session: {},
         cwd: '/',
         fs: {},
-        docs,
         dispatch: async () => { },
     };
     return { ctx, pushed };

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

@@ -11,11 +11,11 @@ export const xferVerb = {
     programmatic: true,
     async run(ctx, args) {
         const ts = Date.now();
-        if (!ctx.docs) {
+        if (!ctx.sh3.docs) {
             ctx.scrollback.push({ kind: 'status', text: 'xfer: document capability not available', level: 'error', ts });
             return;
         }
-        if (!ctx.docs.transferBetweenScopes) {
+        if (!ctx.sh3.docs.transferBetweenScopes) {
             ctx.scrollback.push({ kind: 'status', text: 'xfer: write permission not granted', level: 'error', ts });
             return;
         }
@@ -64,13 +64,13 @@ export const xferVerb = {
                 ctx.scrollback.push({ kind: 'status', text: 'xfer: source and destination are the same', level: 'error', ts });
                 return;
             }
-            await ctx.docs.transferBetweenScopes(srcTenant, srcParsed.shardId, srcParsed.path, dstTenant, dstParsed.shardId, dstParsed.path, moveOpts);
+            await ctx.sh3.docs.transferBetweenScopes(srcTenant, srcParsed.shardId, srcParsed.path, dstTenant, dstParsed.shardId, dstParsed.path, moveOpts);
             const verb = copy ? 'copied' : 'moved';
             ctx.scrollback.push({ kind: 'status', text: `xfer: ${verb} ${positional[0]} → ${positional[1]}`, level: 'info', ts });
             return;
         }
         const prefix = srcParsed.path;
-        const allDocs = await ctx.docs.listDocumentsIn(srcTenant);
+        const allDocs = await ctx.sh3.docs.listDocumentsIn(srcTenant);
         const matching = allDocs.filter((d) => d.shardId === srcParsed.shardId && (!prefix || d.path.startsWith(prefix)));
         if (matching.length === 0) {
             ctx.scrollback.push({ kind: 'status', text: `xfer: no documents found under ${positional[0]}`, level: 'info', ts });
@@ -78,7 +78,7 @@ export const xferVerb = {
         }
         let count = 0;
         for (const doc of matching) {
-            await ctx.docs.transferBetweenScopes(srcTenant, doc.shardId, doc.path, dstTenant, dstParsed.shardId, doc.path, moveOpts);
+            await ctx.sh3.docs.transferBetweenScopes(srcTenant, doc.shardId, doc.path, dstTenant, dstParsed.shardId, doc.path, moveOpts);
             count++;
         }
         const verb = copy ? 'copied' : 'moved';