sh3-core 0.20.2 → 0.21.0

package/dist/createShell.js

@@ -22,11 +22,33 @@ import { registerLoadedBundle } from './registry/register';
 import { attachGlobalListeners } from './actions/listeners';
 import { detectSatelliteMode } from './boot/satelliteMode';
 import { MemoryBackend } from './state/backends';
-import { sessionState } from './projects/session-state.svelte';
+import { sessionState, readPendingScope, PENDING_SCOPE_KEY } from './projects/session-state.svelte';
 import SatelliteShell from './satellite/SatelliteShell.svelte';
 export async function createShell(config) {
     var _a, _b;
     const sUrl = (_a = config === null || config === void 0 ? void 0 : config.serverUrl) !== null && _a !== void 0 ? _a : '';
+    // 0. Restore pending project scope from a reload-triggered scope switch.
+    //    Written before the previous page reload by switchProjectScope(); must
+    //    be set before bootstrap() so shards activate with the correct scope.
+    const pendingProjectId = readPendingScope();
+    if (pendingProjectId !== null) {
+        sessionState.activeProjectId = pendingProjectId;
+    }
+    // Read ?project= injected by Tauri's --project CLI arg (or any deep-link URL).
+    // Guard against overriding an in-session scope switch that wrote to sessionStorage.
+    if (typeof window !== 'undefined' && pendingProjectId === null) {
+        const urlProject = new URLSearchParams(window.location.search).get('project');
+        if (urlProject) {
+            // Mirror switchProjectScope's sessionStorage write so subsequent reloads
+            // within this tab re-enter the same project (readPendingScope will pick it up).
+            sessionStorage.setItem(PENDING_SCOPE_KEY, JSON.stringify({ projectId: urlProject }));
+            sessionState.activeProjectId = urlProject;
+            // Strip the param so it doesn't linger in bookmarks or history.
+            const cleanUrl = new URL(window.location.href);
+            cleanUrl.searchParams.delete('project');
+            history.replaceState(null, '', cleanUrl.toString());
+        }
+    }
     // 1. Platform detection
     const platform = await resolvePlatform();
     if (platform.backends) {
@@ -60,6 +82,11 @@ export async function createShell(config) {
         // but pop-out is currently a Tauri-only POC so we don't fetch it.
         if (platform.localOwner)
             __setActiveScope('local');
+        // Inherit the host's active project scope so shard activation lands in the
+        // correct tenant (satellite opens in the same project context as the host).
+        if (satellite.payload.projectId) {
+            sessionState.activeProjectId = satellite.payload.projectId;
+        }
         __setScopeResolver(() => sessionState.activeProjectId);
         __setShardScopeResolver(() => sessionState.activeProjectId ? 'project' : 'tenant');
         if (config === null || config === void 0 ? void 0 : config.shards)
@@ -138,19 +165,17 @@ export async function createShell(config) {
         for (const app of config.apps)
             registerApp(app);
     }
-    // 7. Bootstrap
+    // 7. Wire scope resolvers before bootstrap so shards activate in the correct scope.
+    __setScopeResolver(() => sessionState.activeProjectId);
+    __setShardScopeResolver(() => sessionState.activeProjectId ? 'project' : 'tenant');
+    // 8. Bootstrap
     const bootstrapConfig = {};
     if (config === null || config === void 0 ? void 0 : config.excludeShards)
         bootstrapConfig.excludeShards = config.excludeShards;
     await bootstrap(bootstrapConfig);
-    // 7b. Wire the document zone's scope resolver to the active project.
-    // When the user enters a project, getActiveScopeId() returns the project
-    // id so all document operations use the project's virtual tenant.
-    __setScopeResolver(() => sessionState.activeProjectId);
-    __setShardScopeResolver(() => sessionState.activeProjectId ? 'project' : 'tenant');
-    // 8. Attach document-level keyboard / focus listeners
+    // 9. Attach document-level keyboard / focus listeners
     attachGlobalListeners();
-    // 9. Mount the sh3
+    // 10. Mount the sh3
     mount(Sh3, { target });
 }
 /**

package/dist/documents/browse.d.ts

@@ -108,6 +108,26 @@ export interface BrowseCapability {
         targetShardId?: string;
         delete?: boolean;
     }): Promise<void>;
+    /**
+     * List all documents in an arbitrary tenant. Write-gated — cross-tenant
+     * enumeration is a privileged operation used by xfer -R for cross-scope recursion.
+     *
+     * Absent (undefined) when `documents:write` is not declared.
+     */
+    listDocumentsIn?(tenantId: string): Promise<Array<DocumentMeta & {
+        shardId: string;
+    }>>;
+    /**
+     * Copy or move a document between any two tenants. Neither tenant needs to
+     * be the active one. Emits documentChanges for both source (delete if
+     * opts.delete is true) and destination (create/update). Throws when src
+     * and dst are identical.
+     *
+     * Absent (undefined) when `documents:write` is not declared.
+     */
+    transferBetweenScopes?(srcTenant: string, srcShardId: string, srcPath: string, dstTenant: string, dstShardId: string, dstPath: string, opts?: {
+        delete?: boolean;
+    }): Promise<void>;
 }
 export interface BrowseCapabilityOptions {
     /** When true, the returned capability exposes `readFrom`. */

package/dist/documents/browse.js

@@ -99,6 +99,41 @@ export function createBrowseCapability(getTenantId, backend, options = { canRead
                 documentChanges.emit({ type: 'delete', path, tenantId, shardId });
             }
         };
+        capability.listDocumentsIn = (tenantId) => backend.listAllDocuments(tenantId);
+        capability.transferBetweenScopes = async (srcTenant, srcShard, srcPath, dstTenant, dstShard, dstPath, opts) => {
+            if (srcTenant === dstTenant && srcShard === dstShard && srcPath === dstPath) {
+                throw new Error('transferBetweenScopes: source and destination are identical');
+            }
+            if (backend.xfer) {
+                const { existed } = await backend.xfer(srcTenant, `${srcShard}/${srcPath}`, dstTenant, `${dstShard}/${dstPath}`, { move: opts === null || opts === void 0 ? void 0 : opts.delete });
+                documentChanges.emit({
+                    type: existed ? 'update' : 'create',
+                    path: dstPath,
+                    tenantId: dstTenant,
+                    shardId: dstShard,
+                });
+                if (opts === null || opts === void 0 ? void 0 : opts.delete) {
+                    documentChanges.emit({ type: 'delete', path: srcPath, tenantId: srcTenant, shardId: srcShard });
+                }
+                return;
+            }
+            const content = await backend.read(srcTenant, srcShard, srcPath);
+            if (content === null) {
+                throw new Error(`Document not found at ${srcShard}/${srcPath} in scope ${srcTenant}`);
+            }
+            const existed = await backend.exists(dstTenant, dstShard, dstPath);
+            await backend.write(dstTenant, dstShard, dstPath, content);
+            documentChanges.emit({
+                type: existed ? 'update' : 'create',
+                path: dstPath,
+                tenantId: dstTenant,
+                shardId: dstShard,
+            });
+            if (opts === null || opts === void 0 ? void 0 : opts.delete) {
+                await backend.delete(srcTenant, srcShard, srcPath);
+                documentChanges.emit({ type: 'delete', path: srcPath, tenantId: srcTenant, shardId: srcShard });
+            }
+        };
     }
     return capability;
 }

package/dist/documents/browse.test.js

@@ -304,4 +304,129 @@ describe('BrowseCapability', () => {
             expect(await be.read('t2', 's', 'secret.txt')).toBe('hidden');
         });
     });
+    describe('listDocumentsIn (documents:write gate)', () => {
+        it('is absent when canWrite is false', () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: false });
+            expect(browse.listDocumentsIn).toBeUndefined();
+        });
+        it('lists documents from an arbitrary tenant, not the active one', async () => {
+            const be = new MemoryDocumentBackend();
+            await be.write('t2', 'notes', 'a.md', 'hello');
+            await be.write('t2', 'notes', 'b.md', 'world');
+            await be.write('t1', 'notes', 'c.md', 'active');
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: true });
+            const docs = await browse.listDocumentsIn('t2');
+            expect(docs.map((d) => d.path).sort()).toEqual(['a.md', 'b.md']);
+        });
+    });
+    describe('transferBetweenScopes (documents:write gate)', () => {
+        it('is absent when canWrite is false', () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: false });
+            expect(browse.transferBetweenScopes).toBeUndefined();
+        });
+        it('copies a document from one tenant to another and emits create', async () => {
+            const be = new MemoryDocumentBackend();
+            await be.write('t1', 'notes', 'draft.md', 'content');
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: true });
+            const events = [];
+            const unsub = documentChanges.subscribe((c) => events.push(c));
+            await browse.transferBetweenScopes('t1', 'notes', 'draft.md', 't2', 'notes', 'draft.md');
+            expect(await be.read('t2', 'notes', 'draft.md')).toBe('content');
+            expect(await be.read('t1', 'notes', 'draft.md')).toBe('content'); // source intact
+            expect(events).toEqual([
+                { type: 'create', path: 'draft.md', tenantId: 't2', shardId: 'notes' },
+            ]);
+            unsub();
+        });
+        it('deletes source and emits delete when opts.delete is true', async () => {
+            const be = new MemoryDocumentBackend();
+            await be.write('t1', 'notes', 'draft.md', 'content');
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: true });
+            const events = [];
+            const unsub = documentChanges.subscribe((c) => events.push(c));
+            await browse.transferBetweenScopes('t1', 'notes', 'draft.md', 't2', 'notes', 'draft.md', { delete: true });
+            expect(await be.read('t2', 'notes', 'draft.md')).toBe('content');
+            expect(await be.read('t1', 'notes', 'draft.md')).toBeNull();
+            expect(events).toEqual([
+                { type: 'create', path: 'draft.md', tenantId: 't2', shardId: 'notes' },
+                { type: 'delete', path: 'draft.md', tenantId: 't1', shardId: 'notes' },
+            ]);
+            unsub();
+        });
+        it('emits update (not create) when destination already exists', async () => {
+            const be = new MemoryDocumentBackend();
+            await be.write('t1', 'notes', 'draft.md', 'v1');
+            await be.write('t2', 'notes', 'draft.md', 'old');
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: true });
+            const events = [];
+            const unsub = documentChanges.subscribe((c) => events.push(c));
+            await browse.transferBetweenScopes('t1', 'notes', 'draft.md', 't2', 'notes', 'draft.md');
+            expect(events[0].type).toBe('update');
+            unsub();
+        });
+        it('throws when source and destination are identical', async () => {
+            const be = new MemoryDocumentBackend();
+            await be.write('t1', 'notes', 'draft.md', 'x');
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: true });
+            await expect(browse.transferBetweenScopes('t1', 'notes', 'draft.md', 't1', 'notes', 'draft.md')).rejects.toThrow('identical');
+        });
+        it('throws when source document does not exist', async () => {
+            const be = new MemoryDocumentBackend();
+            const browse = createBrowseCapability(() => 't1', be, { canRead: false, canWrite: true });
+            await expect(browse.transferBetweenScopes('t1', 'notes', 'missing.md', 't2', 'notes', 'missing.md')).rejects.toThrow('not found');
+        });
+    });
+});
+describe('transferBetweenScopes', () => {
+    it('delegates to backend.xfer when the method is present', async () => {
+        const xfer = vi.fn(async () => ({ existed: false }));
+        const be = new MemoryDocumentBackend();
+        be.xfer = xfer;
+        const browse = createBrowseCapability(() => 'alice', be, { canRead: true, canWrite: true });
+        await browse.transferBetweenScopes('alice', 'notes', 'draft.md', 'proj-1', 'notes', 'draft.md', { delete: true });
+        expect(xfer).toHaveBeenCalledWith('alice', 'notes/draft.md', 'proj-1', 'notes/draft.md', { move: true });
+    });
+    it('emits create on dst and delete on src when move=true and existed=false', async () => {
+        const changes = [];
+        const unsub = documentChanges.subscribe((c) => changes.push(c));
+        const xfer = vi.fn(async () => ({ existed: false }));
+        const be = new MemoryDocumentBackend();
+        be.xfer = xfer;
+        const browse = createBrowseCapability(() => 'alice', be, { canRead: true, canWrite: true });
+        await browse.transferBetweenScopes('alice', 'notes', 'draft.md', 'proj-1', 'notes', 'draft.md', { delete: true });
+        unsub();
+        expect(changes).toContainEqual(expect.objectContaining({ type: 'create', path: 'draft.md', tenantId: 'proj-1', shardId: 'notes' }));
+        expect(changes).toContainEqual(expect.objectContaining({ type: 'delete', path: 'draft.md', tenantId: 'alice', shardId: 'notes' }));
+    });
+    it('emits update on dst when existed=true', async () => {
+        const changes = [];
+        const unsub = documentChanges.subscribe((c) => changes.push(c));
+        const xfer = vi.fn(async () => ({ existed: true }));
+        const be = new MemoryDocumentBackend();
+        be.xfer = xfer;
+        const browse = createBrowseCapability(() => 'alice', be, { canRead: true, canWrite: true });
+        await browse.transferBetweenScopes('alice', 'notes', 'draft.md', 'proj-1', 'notes', 'draft.md', { delete: false });
+        unsub();
+        expect(changes).toContainEqual(expect.objectContaining({ type: 'update', path: 'draft.md', tenantId: 'proj-1', shardId: 'notes' }));
+    });
+    it('falls back to read+write when backend.xfer is absent', async () => {
+        const be = new MemoryDocumentBackend();
+        await be.write('alice', 'notes', 'draft.md', 'hello');
+        const browse = createBrowseCapability(() => 'alice', be, { canRead: true, canWrite: true });
+        await browse.transferBetweenScopes('alice', 'notes', 'draft.md', 'proj-1', 'notes', 'draft.md', { delete: false });
+        const copied = await be.read('proj-1', 'notes', 'draft.md');
+        expect(copied).toBe('hello');
+        const original = await be.read('alice', 'notes', 'draft.md');
+        expect(original).toBe('hello');
+    });
+    it('falls back to read+write+delete when backend.xfer is absent and delete=true', async () => {
+        const be = new MemoryDocumentBackend();
+        await be.write('alice', 'notes', 'draft.md', 'hello');
+        const browse = createBrowseCapability(() => 'alice', be, { canRead: true, canWrite: true });
+        await browse.transferBetweenScopes('alice', 'notes', 'draft.md', 'proj-1', 'notes', 'draft.md', { delete: true });
+        expect(await be.read('alice', 'notes', 'draft.md')).toBeNull();
+        expect(await be.read('proj-1', 'notes', 'draft.md')).toBe('hello');
+    });
 });

package/dist/documents/config.d.ts

@@ -6,12 +6,8 @@ export declare function __setScopeResolver(resolver: (() => string | null) | nul
 export declare function getActiveScopeId(): string;
 /** The user's base (personal) tenant id — never overridden by the project resolver. */
 export declare function getPersonalScopeId(): string;
-/** @deprecated use getActiveScopeId — kept until callers migrate. */
-export declare function getTenantId(): string;
 export declare function getDocumentBackend(): DocumentBackend;
 /** Host-only. Set the active scope id before bootstrap(). */
 export declare function __setActiveScope(id: string): void;
-/** @deprecated use __setActiveScope — kept until callers migrate. */
-export declare function __setTenantId(id: string): void;
 /** Host-only. Swap the document backend before bootstrap(). */
 export declare function __setDocumentBackend(b: DocumentBackend): void;

package/dist/documents/config.js

@@ -31,10 +31,6 @@ export function getActiveScopeId() {
 export function getPersonalScopeId() {
     return scopeId;
 }
-/** @deprecated use getActiveScopeId — kept until callers migrate. */
-export function getTenantId() {
-    return getActiveScopeId();
-}
 export function getDocumentBackend() {
     return backend;
 }
@@ -42,10 +38,6 @@ export function getDocumentBackend() {
 export function __setActiveScope(id) {
     scopeId = id;
 }
-/** @deprecated use __setActiveScope — kept until callers migrate. */
-export function __setTenantId(id) {
-    __setActiveScope(id);
-}
 /** Host-only. Swap the document backend before bootstrap(). */
 export function __setDocumentBackend(b) {
     backend = b;

package/dist/documents/http-backend.d.ts

@@ -31,6 +31,11 @@ export declare class HttpDocumentBackend implements DocumentBackend {
         origin: string;
     } | string): Promise<void>;
     readBranch(tenantId: string, shardId: string, path: string, origin: string): Promise<string | null>;
+    xfer(srcTenant: string, srcPath: string, dstTenant: string, dstPath: string, opts?: {
+        move?: boolean;
+    }): Promise<{
+        existed: boolean;
+    }>;
     rename(tenantId: string, shardId: string, oldPath: string, newPath: string): Promise<void>;
     mkdir(tenantId: string, shardId: string, path: string): Promise<void>;
     rmdir(tenantId: string, shardId: string, path: string, opts: {

package/dist/documents/http-backend.js

@@ -128,6 +128,31 @@ export class HttpDocumentBackend {
             throw new Error(`readBranch failed: ${res.status}`);
         return res.text();
     }
+    async xfer(srcTenant, srcPath, dstTenant, dstPath, opts) {
+        var _a;
+        const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/xfer`;
+        const res = await apiFetch(url, {
+            method: 'POST',
+            headers: Object.assign(Object.assign({}, __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this)), { 'Content-Type': 'application/json' }),
+            body: JSON.stringify({
+                src: { scope: srcTenant, path: srcPath },
+                dst: { scope: dstTenant, path: dstPath },
+                move: (_a = opts === null || opts === void 0 ? void 0 : opts.move) !== null && _a !== void 0 ? _a : false,
+            }),
+            credentials: 'include',
+        });
+        if (!res.ok) {
+            let detail = `HTTP ${res.status}`;
+            try {
+                const b = await res.json();
+                if (b.error)
+                    detail = b.error;
+            }
+            catch ( /* not JSON */_b) { /* not JSON */ }
+            throw new Error(`xfer failed: ${detail}`);
+        }
+        return res.json();
+    }
     async rename(tenantId, shardId, oldPath, newPath) {
         const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${oldPath}/rename`;
         const headers = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this)), { 'Content-Type': 'application/json' });

package/dist/documents/http-backend.test.js

@@ -129,3 +129,69 @@ describe('HttpDocumentBackend folder ops', () => {
         expect(result).toEqual(['c']);
     });
 });
+describe('HttpDocumentBackend.xfer', () => {
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('POSTs to /api/xfer with src, dst, and move in the body', async () => {
+        var _a, _b;
+        const calls = [];
+        globalThis.fetch = (async (url, init) => {
+            calls.push({ url: String(url), init });
+            return new Response(JSON.stringify({ ok: true, existed: false }), { status: 200 });
+        });
+        const be = new HttpDocumentBackend('http://server', 'apikey-1');
+        const result = await be.xfer('alice', 'notes/draft.md', 'proj-1', 'notes/draft.md', { move: true });
+        expect(calls).toHaveLength(1);
+        expect(calls[0].url).toBe('http://server/api/xfer');
+        expect((_a = calls[0].init) === null || _a === void 0 ? void 0 : _a.method).toBe('POST');
+        const body = JSON.parse((_b = calls[0].init) === null || _b === void 0 ? void 0 : _b.body);
+        expect(body).toEqual({
+            src: { scope: 'alice', path: 'notes/draft.md' },
+            dst: { scope: 'proj-1', path: 'notes/draft.md' },
+            move: true,
+        });
+        expect(result).toEqual({ ok: true, existed: false });
+    });
+    it('sends move=false when opts.move is false', async () => {
+        var _a;
+        const calls = [];
+        globalThis.fetch = (async (url, init) => {
+            calls.push({ url: String(url), init });
+            return new Response(JSON.stringify({ ok: true, existed: true }), { status: 200 });
+        });
+        const be = new HttpDocumentBackend('http://server');
+        await be.xfer('alice', 'notes/a.md', 'proj-1', 'notes/a.md', { move: false });
+        const body = JSON.parse((_a = calls[0].init) === null || _a === void 0 ? void 0 : _a.body);
+        expect(body.move).toBe(false);
+    });
+    it('sends move=false when opts is omitted', async () => {
+        var _a;
+        const calls = [];
+        globalThis.fetch = (async (url, init) => {
+            calls.push({ url: String(url), init });
+            return new Response(JSON.stringify({ ok: true, existed: false }), { status: 200 });
+        });
+        const be = new HttpDocumentBackend('http://server');
+        await be.xfer('alice', 'notes/a.md', 'proj-1', 'notes/a.md');
+        const body = JSON.parse((_a = calls[0].init) === null || _a === void 0 ? void 0 : _a.body);
+        expect(body.move).toBe(false);
+    });
+    it('includes Authorization header when apiKey is set', async () => {
+        var _a;
+        const calls = [];
+        globalThis.fetch = (async (url, init) => {
+            calls.push({ url: String(url), init });
+            return new Response(JSON.stringify({ ok: true, existed: false }), { status: 200 });
+        });
+        const be = new HttpDocumentBackend('http://server', 'my-key');
+        await be.xfer('alice', 'notes/a.md', 'proj-1', 'notes/a.md');
+        const headers = (_a = calls[0].init) === null || _a === void 0 ? void 0 : _a.headers;
+        expect(headers['Authorization']).toBe('Bearer my-key');
+    });
+    it('throws with server error message on non-ok response', async () => {
+        globalThis.fetch = (async () => new Response(JSON.stringify({ error: 'Source document not found' }), { status: 404 }));
+        const be = new HttpDocumentBackend('http://server');
+        await expect(be.xfer('alice', 'notes/missing.md', 'proj-1', 'notes/missing.md')).rejects.toThrow('Source document not found');
+    });
+});

package/dist/documents/index.d.ts

@@ -3,6 +3,6 @@ export { MemoryDocumentBackend, IndexedDBDocumentBackend } from './backends';
 export { HttpDocumentBackend } from './http-backend';
 export { createDocumentHandle } from './handle';
 export { documentChanges } from './notifications';
-export { getActiveScopeId, getTenantId, getDocumentBackend, __setActiveScope, __setTenantId, __setDocumentBackend, __setScopeResolver, } from './config';
+export { getActiveScopeId, getDocumentBackend, __setActiveScope, __setDocumentBackend, __setScopeResolver, } from './config';
 export type { SyncPolicy, SyncPolicyRule, DocStatus, ConflictFile, ConflictBranch, } from './sync-types';
 export { PERMISSION_SYNC_PEER, PERMISSION_SYNC_POLICY, } from './sync-types';

package/dist/documents/index.js

@@ -5,5 +5,5 @@ export { MemoryDocumentBackend, IndexedDBDocumentBackend } from './backends';
 export { HttpDocumentBackend } from './http-backend';
 export { createDocumentHandle } from './handle';
 export { documentChanges } from './notifications';
-export { getActiveScopeId, getTenantId, getDocumentBackend, __setActiveScope, __setTenantId, __setDocumentBackend, __setScopeResolver, } from './config';
+export { getActiveScopeId, getDocumentBackend, __setActiveScope, __setDocumentBackend, __setScopeResolver, } from './config';
 export { PERMISSION_SYNC_PEER, PERMISSION_SYNC_POLICY, } from './sync-types';

package/dist/documents/types.d.ts

@@ -192,6 +192,17 @@ export interface DocumentBackend {
      * Optional; only supported by HttpDocumentBackend in v1.
      */
     readBranch?(tenantId: string, shardId: string, path: string, origin: string): Promise<string | null>;
+    /**
+     * Server-side cross-scope transfer. When implemented, `transferBetweenScopes`
+     * delegates to this rather than doing client-side read+write, bypassing the
+     * per-shard app allowlist check. `srcPath` and `dstPath` are in the form
+     * `shardId/filePath`. Returns whether the destination document already existed.
+     */
+    xfer?(srcTenant: string, srcPath: string, dstTenant: string, dstPath: string, opts?: {
+        move?: boolean;
+    }): Promise<{
+        existed: boolean;
+    }>;
 }
 /**
  * Shard-facing document handle returned by `ctx.documents()`. Binds

package/dist/env/client.d.ts

@@ -27,18 +27,14 @@ export interface ServerInstallResult {
     }>;
 }
 /**
- * Install a package on the server via multipart upload.
- * The client has already fetched and integrity-verified the client bundle
- * (and the server bundle, if present and serverIntegrity was declared).
+ * Request the server to install a package autonomously.
+ * The server fetches and validates the archive from the registry itself.
  *
- * @param manifest - Package manifest metadata to persist server-side.
- * @param clientBundle - Verified client ESM bundle bytes.
- * @param serverBundle - Optional verified server ESM bundle bytes. When
- *   provided, the server writes it to `server.js` and hot-mounts the
- *   shard's routes. If the mount fails, the entire install is rolled
- *   back server-side.
+ * @param registryUrl - URL of the registry.json that lists the package.
+ * @param packageId - The package id to install.
+ * @param version - The exact version string to install.
  */
-export declare function serverInstallPackage(manifest: Record<string, unknown>, clientBundle: ArrayBuffer, serverBundle?: ArrayBuffer): Promise<ServerInstallResult>;
+export declare function requestServerInstall(registryUrl: string, packageId: string, version: string): Promise<ServerInstallResult>;
 /**
  * Uninstall a package from the server.
  */

package/dist/env/client.js

@@ -45,35 +45,25 @@ export async function putEnvState(shardId, state) {
     }
 }
 /**
- * Install a package on the server via multipart upload.
- * The client has already fetched and integrity-verified the client bundle
- * (and the server bundle, if present and serverIntegrity was declared).
+ * Request the server to install a package autonomously.
+ * The server fetches and validates the archive from the registry itself.
  *
- * @param manifest - Package manifest metadata to persist server-side.
- * @param clientBundle - Verified client ESM bundle bytes.
- * @param serverBundle - Optional verified server ESM bundle bytes. When
- *   provided, the server writes it to `server.js` and hot-mounts the
- *   shard's routes. If the mount fails, the entire install is rolled
- *   back server-side.
+ * @param registryUrl - URL of the registry.json that lists the package.
+ * @param packageId - The package id to install.
+ * @param version - The exact version string to install.
  */
-export async function serverInstallPackage(manifest, clientBundle, serverBundle) {
+export async function requestServerInstall(registryUrl, packageId, version) {
     var _a;
     if (!isAdmin())
         throw new Error('Cannot install: not elevated to admin');
     const auth = getAuthHeader();
-    const form = new FormData();
-    form.append('manifest', new Blob([JSON.stringify(manifest)], { type: 'application/json' }), 'manifest.json');
-    form.append('client', new Blob([clientBundle], { type: 'application/javascript' }), 'client.js');
-    if (serverBundle !== undefined) {
-        form.append('server', new Blob([serverBundle], { type: 'application/javascript' }), 'server.js');
-    }
-    const headers = {};
+    const headers = { 'Content-Type': 'application/json' };
     if (auth)
         headers['Authorization'] = auth;
     const res = await apiFetch(`${getEnvServerUrl()}/api/packages/install`, {
         method: 'POST',
         headers,
-        body: form,
+        body: JSON.stringify({ registryUrl, packageId, version }),
         credentials: 'omit',
     });
     if (!res.ok) {
@@ -84,9 +74,9 @@ export async function serverInstallPackage(manifest, clientBundle, serverBundle)
         catch ( /* non-JSON */_b) { /* non-JSON */ }
         return {
             ok: false,
-            error: typeof body.error === 'string' ? body.error : `HTTP ${res.status}`,
-            code: typeof body.code === 'string' ? body.code : undefined,
-            missing: Array.isArray(body.missing) ? body.missing : undefined,
+            error: typeof body['error'] === 'string' ? body['error'] : `HTTP ${res.status}`,
+            code: typeof body['code'] === 'string' ? body['code'] : undefined,
+            missing: Array.isArray(body['missing']) ? body['missing'] : undefined,
         };
     }
     const body = await res.json();

package/dist/env/index.d.ts

@@ -1,2 +1,3 @@
 export type { EnvState } from './types';
-export { __setEnvServerUrl, getEnvServerUrl, fetchEnvState, putEnvState, serverInstallPackage, serverUninstallPackage, fetchServerPackages, } from './client';
+export { __setEnvServerUrl, getEnvServerUrl, fetchEnvState, putEnvState, requestServerInstall, serverUninstallPackage, fetchServerPackages, } from './client';
+export type { ServerInstallResult } from './client';

package/dist/env/index.js

@@ -1 +1 @@
-export { __setEnvServerUrl, getEnvServerUrl, fetchEnvState, putEnvState, serverInstallPackage, serverUninstallPackage, fetchServerPackages, } from './client';
+export { __setEnvServerUrl, getEnvServerUrl, fetchEnvState, putEnvState, requestServerInstall, serverUninstallPackage, fetchServerPackages, } from './client';

package/dist/host-entry.d.ts

@@ -1,6 +1,6 @@
 export { registerShard, registerApp, bootstrap, __setBackend, setLocalOwner } from './host';
 export type { BootstrapConfig } from './host';
-export { __setActiveScope, __setTenantId, __setDocumentBackend } from './host';
+export { __setActiveScope, __setDocumentBackend } from './host';
 export type { Backend } from './state/types';
 export type { DocumentBackend } from './documents/types';
 export { HttpDocumentBackend } from './documents/http-backend';

package/dist/host-entry.js

@@ -6,7 +6,7 @@
  * should touch this path. Shards and apps must not import from here.
  */
 export { registerShard, registerApp, bootstrap, __setBackend, setLocalOwner } from './host';
-export { __setActiveScope, __setTenantId, __setDocumentBackend } from './host';
+export { __setActiveScope, __setDocumentBackend } from './host';
 export { HttpDocumentBackend } from './documents/http-backend';
 export { IndexedDBDocumentBackend, MemoryDocumentBackend } from './documents/backends';
 export { __setEnvServerUrl } from './env/index';

package/dist/host.d.ts

@@ -4,7 +4,7 @@ import { __setBackend } from './state/zones.svelte';
 import { setLocalOwner } from './auth/index';
 export { __setBackend };
 export { setLocalOwner };
-export { __setActiveScope, __setTenantId, __setDocumentBackend } from './documents/config';
+export { __setActiveScope, __setDocumentBackend } from './documents/config';
 export declare function registerShard(shard: Parameters<typeof registerShardInternal>[0]): void;
 export { registerApp };
 export interface BootstrapConfig {

package/dist/host.js

@@ -38,7 +38,7 @@ import { installWebEmitter } from './navigation/platform-web';
 import { returnToHome } from './apps/lifecycle';
 export { __setBackend };
 export { setLocalOwner };
-export { __setActiveScope, __setTenantId, __setDocumentBackend } from './documents/config';
+export { __setActiveScope, __setDocumentBackend } from './documents/config';
 import { getActiveScopeId } from './documents/config';
 export function registerShard(shard) {
     registerShardInternal(shard);

package/dist/layout/slotHostPool.svelte.js

@@ -75,7 +75,7 @@ function onViewRegistered(viewId, factory) {
             if (entry.handle !== undefined)
                 return; // already mounted by a race
             entry.handle = factory.mount(entry.host, ctx);
-            if (((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) || slotId.startsWith('float:')) {
+            if (((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) || slotId.startsWith('float:') || slotId.startsWith('standalone:')) {
                 closableState[slotId] = true;
             }
             if ((_b = entry.handle) === null || _b === void 0 ? void 0 : _b.onResize) {
@@ -179,7 +179,7 @@ function createHost(slotId, viewId, label, meta) {
             },
         };
         entry.handle = factory === null || factory === void 0 ? void 0 : factory.mount(host, ctx);
-        if (((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) || slotId.startsWith('float:')) {
+        if (((_a = entry.handle) === null || _a === void 0 ? void 0 : _a.closable) || slotId.startsWith('float:') || slotId.startsWith('standalone:')) {
             closableState[slotId] = true;
         }
         // The pool owns the ResizeObserver so its lifetime matches the

package/dist/overlays/FloatFrame.svelte

@@ -262,6 +262,7 @@
         title: entry.title,
         size: { w: entry.size.w, h: entry.size.h },
         activateShards: walkShardsForContent(entry.content),
+        projectId: sh3.getActiveScope().isProject ? sh3.getActiveScope().id : undefined,
       });
       floatManager.close(entry.id);
     } catch (err) {

package/dist/projects/session-state.svelte.d.ts

@@ -1,3 +1,6 @@
+export declare const PENDING_SCOPE_KEY = "sh3:pending-scope";
+export declare function readPendingScope(): string | null;
+export declare function switchProjectScope(projectId: string | null): void;
 export declare const sessionState: {
     activeProjectId: string | null;
 };