sh3-core 0.19.6 → 0.20.2

package/dist/chrome/MenuSheet.svelte.test.js

@@ -1,8 +1,8 @@
 /*
- * DOM smoke for MenuSheet — verifies open/closed rendering. The
- * container/item resolution is exercised via the same model functions
- * MenuBar uses; their unit tests cover the resolution semantics so
- * this test only asserts the wrapper structure.
+ * DOM smoke for MenuSheet — verifies the push-navigation modal card
+ * renders correctly. The container/item resolution is exercised via
+ * the same model functions MenuBar uses; their unit tests cover the
+ * resolution semantics so this test only asserts the wrapper structure.
  */
 import { describe, it, expect, afterEach } from 'vitest';
 import { mount, unmount, flushSync } from 'svelte';
@@ -21,26 +21,38 @@ afterEach(() => {
     }
 });
 describe('MenuSheet (dom)', () => {
-    it('renders nothing when closed', () => {
+    it('renders the menu sheet region with a title "Menu" when no actions registered', () => {
         host = document.createElement('div');
         document.body.appendChild(host);
         mounted = mount(MenuSheetAny, {
             target: host,
-            props: { open: false, onClose: () => { } },
+            props: { close: () => { } },
         });
         flushSync();
-        expect(host.querySelector('[data-sh3-region="menu-sheet"]')).toBeNull();
+        const sheet = host.querySelector('[data-sh3-region="menu-sheet"]');
+        expect(sheet).not.toBeNull();
+        expect(sheet.querySelector('.title').textContent).toContain('Menu');
     });
-    it('renders a sheet with a Cancel button when open', () => {
+    it('does not show back button at root level', () => {
         host = document.createElement('div');
         document.body.appendChild(host);
         mounted = mount(MenuSheetAny, {
             target: host,
-            props: { open: true, onClose: () => { } },
+            props: { close: () => { } },
         });
         flushSync();
-        const sheet = host.querySelector('[data-sh3-region="menu-sheet"]');
-        expect(sheet).not.toBeNull();
-        expect(sheet.querySelector('.cancel').textContent).toContain('Cancel');
+        const backBtn = host.querySelector('button[aria-label="Back"]');
+        expect(backBtn).toBeNull();
+    });
+    it('renders empty state when no items available', () => {
+        host = document.createElement('div');
+        document.body.appendChild(host);
+        mounted = mount(MenuSheetAny, {
+            target: host,
+            props: { close: () => { } },
+        });
+        flushSync();
+        const empty = host.querySelector('.empty');
+        expect(empty).not.toBeNull();
     });
 });

package/dist/createShell.js

@@ -13,7 +13,8 @@ import { resolvePlatform } from './platform/index';
 import { apiFetch } from './transport/apiFetch';
 import { hydrateTokenOverrides } from './theme';
 import { __setEnvServerUrl, getEnvServerUrl } from './env/index';
-import { __setActiveScope } from './documents/config';
+import { __setActiveScope, __setScopeResolver } from './documents/config';
+import { __setScopeResolver as __setShardScopeResolver } from './shards/activate.svelte';
 import { initFromBoot } from './auth/index';
 import SignInWall from './auth/SignInWall.svelte';
 import { loadBundleModule } from './registry/loader';
@@ -21,6 +22,7 @@ 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 SatelliteShell from './satellite/SatelliteShell.svelte';
 export async function createShell(config) {
     var _a, _b;
@@ -31,9 +33,6 @@ export async function createShell(config) {
         __setBackend('workspace', platform.backends.workspace);
         __setBackend('user', platform.backends.user);
     }
-    if (platform.localOwner) {
-        setLocalOwner();
-    }
     __setEnvServerUrl(sUrl);
     hydrateTokenOverrides();
     // 2. Resolve mount target early (needed for both sign-in wall and sh3)
@@ -61,6 +60,8 @@ 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');
+        __setScopeResolver(() => sessionState.activeProjectId);
+        __setShardScopeResolver(() => sessionState.activeProjectId ? 'project' : 'tenant');
         if (config === null || config === void 0 ? void 0 : config.shards)
             for (const shard of config.shards)
                 registerShard(shard);
@@ -84,33 +85,38 @@ export async function createShell(config) {
         mount(SatelliteShell, { target, props: { payload: satellite.payload } });
         return;
     }
-    // 3. Fetch boot config (skip for purely-local owners; remoteAuth
-    //    forces it for cross-origin Tauri clients).
+    // 3. Fetch boot config. Always fetched — local-owner (Tauri sidecar)
+    //    needs the real sh3s_ session token minted by /api/boot.
     let bootConfig = null;
-    const useServerAuth = !platform.localOwner || (config === null || config === void 0 ? void 0 : config.remoteAuth) === true;
-    if (useServerAuth) {
-        try {
-            const res = await apiFetch(`${sUrl}/api/boot`);
-            if (res.ok) {
-                bootConfig = await res.json();
-            }
-        }
-        catch (_c) {
-            // Server unreachable — boot without auth (offline mode)
+    try {
+        const res = await apiFetch(`${sUrl}/api/boot`);
+        if (res.ok) {
+            bootConfig = await res.json();
         }
     }
+    catch (_c) {
+        // Server unreachable — boot without auth (offline mode)
+    }
     // 4. Auth decision point
     if (platform.localOwner && !(config === null || config === void 0 ? void 0 : config.remoteAuth)) {
-        // Local-owner (Tauri/dev): no auth, no sign-in, scope is 'local'.
-        // setLocalOwner() already called above — admin is assumed.
-        __setActiveScope('local');
+        // Local-owner (Tauri sidecar): boot minted a real sh3s_ session.
+        // initFromBoot stores the token; fall back to synthetic local if
+        // the server was unreachable (should never happen in sidecar mode).
+        if (bootConfig) {
+            initFromBoot(sUrl, bootConfig);
+            __setActiveScope(bootConfig.tenantId);
+        }
+        else {
+            setLocalOwner();
+            __setActiveScope('local');
+        }
     }
     else if (bootConfig) {
         initFromBoot(sUrl, bootConfig);
         __setActiveScope(bootConfig.tenantId);
         const { auth, session } = bootConfig;
-        // Hard gate: no session, auth required, no guest allowed → sign-in wall
-        if (!session && auth.required && !auth.guestAllowed) {
+        // Hard gate: no session and no guest allowed → sign-in wall
+        if (!session && !auth.guestAllowed) {
             await showSignInWall(target, bootConfig);
             // After successful sign-in, re-fetch boot config
             const res = await apiFetch(`${sUrl}/api/boot`);
@@ -137,6 +143,11 @@ export async function createShell(config) {
     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
     attachGlobalListeners();
     // 9. Mount the sh3

package/dist/createShell.remoteAuth.test.js

@@ -48,11 +48,17 @@ describe('createShell remoteAuth flag', () => {
         }
         expect(calls.some(u => u === 'https://remote.example.com/api/boot')).toBe(true);
     });
-    it('keeps the legacy localOwner short-circuit when remoteAuth is absent', async () => {
+    it('fetches /api/boot in localOwner mode (sidecar needs the real sh3s_ token)', async () => {
         const calls = [];
         globalThis.fetch = vi.fn(async (input) => {
             calls.push(String(input));
-            return new Response('ok');
+            return new Response(JSON.stringify({
+                version: '0.20.0',
+                tenantId: 'local',
+                auth: { guestAllowed: false, selfRegistration: false },
+                session: { token: 'sh3s_abc', userId: 'local', role: 'admin', expiresAt: Number.MAX_SAFE_INTEGER },
+                user: { id: 'local', username: 'local', displayName: 'Local Owner', role: 'admin', createdAt: '', updatedAt: '' },
+            }), { status: 200, headers: { 'Content-Type': 'application/json' } });
         });
         vi.doMock('./platform/index', () => ({
             resolvePlatform: async () => ({ backends: null, localOwner: true }),
@@ -66,6 +72,6 @@ describe('createShell remoteAuth flag', () => {
         catch (_a) {
             // ignore — assertion below is the contract.
         }
-        expect(calls.some(u => u.endsWith('/api/boot'))).toBe(false);
+        expect(calls.some(u => u.endsWith('/api/boot'))).toBe(true);
     });
 });

package/dist/documents/backends.d.ts

@@ -13,6 +13,12 @@ export declare class MemoryDocumentBackend implements DocumentBackend {
         shardId: string;
     }>>;
     readMeta(tenantId: string, shardId: string, path: string): Promise<DocStatus | null>;
+    mkdir(tenantId: string, shardId: string, path: string): Promise<void>;
+    rmdir(tenantId: string, shardId: string, path: string, opts: {
+        recursive: boolean;
+    }): Promise<void>;
+    renameFolder(tenantId: string, shardId: string, oldPath: string, newPath: string): Promise<void>;
+    listFolders(tenantId: string, shardId: string, prefix: string): Promise<string[]>;
 }
 export declare class IndexedDBDocumentBackend implements DocumentBackend {
     #private;
@@ -26,4 +32,10 @@ export declare class IndexedDBDocumentBackend implements DocumentBackend {
     listAllDocuments(tenantId: string): Promise<Array<DocumentMeta & {
         shardId: string;
     }>>;
+    mkdir(tenantId: string, shardId: string, path: string): Promise<void>;
+    rmdir(tenantId: string, shardId: string, path: string, opts: {
+        recursive: boolean;
+    }): Promise<void>;
+    renameFolder(tenantId: string, shardId: string, oldPath: string, newPath: string): Promise<void>;
+    listFolders(tenantId: string, shardId: string, prefix: string): Promise<string[]>;
 }

package/dist/documents/backends.js

@@ -16,7 +16,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _MemoryDocumentBackend_store, _IndexedDBDocumentBackend_instances, _IndexedDBDocumentBackend_dbPromise, _IndexedDBDocumentBackend_db, _IndexedDBDocumentBackend_tx;
+var _MemoryDocumentBackend_store, _MemoryDocumentBackend_folders, _IndexedDBDocumentBackend_instances, _IndexedDBDocumentBackend_dbPromise, _IndexedDBDocumentBackend_db, _IndexedDBDocumentBackend_tx, _IndexedDBDocumentBackend_txOn;
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -29,6 +29,7 @@ function keyPrefix(tenantId, shardId) {
 export class MemoryDocumentBackend {
     constructor() {
         _MemoryDocumentBackend_store.set(this, new Map());
+        _MemoryDocumentBackend_folders.set(this, new Set()); // composite keys: `${tenant}/${shard}/${path}`
     }
     async read(tenantId, shardId, path) {
         const entry = __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").get(compositeKey(tenantId, shardId, path));
@@ -111,14 +112,111 @@ export class MemoryDocumentBackend {
             return null;
         return { exists: true, version: 1, syncMode: 'sync', syncState: 'synced' };
     }
+    async mkdir(tenantId, shardId, path) {
+        if (__classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").has(compositeKey(tenantId, shardId, path))) {
+            throw new Error(`Cannot mkdir ${path}: a document occupies this path`);
+        }
+        __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f").add(compositeKey(tenantId, shardId, path));
+    }
+    async rmdir(tenantId, shardId, path, opts) {
+        const folderKey = compositeKey(tenantId, shardId, path);
+        const docPrefix = folderKey + '/';
+        const docDescendants = [];
+        const folderDescendants = [];
+        for (const key of __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").keys()) {
+            if (key.startsWith(docPrefix))
+                docDescendants.push(key);
+        }
+        for (const key of __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f")) {
+            if (key === folderKey)
+                continue;
+            if (key.startsWith(docPrefix))
+                folderDescendants.push(key);
+        }
+        if (!opts.recursive && (docDescendants.length > 0 || folderDescendants.length > 0)) {
+            throw new Error(`Cannot rmdir ${path}: folder is not empty`);
+        }
+        for (const k of docDescendants)
+            __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").delete(k);
+        for (const k of folderDescendants)
+            __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f").delete(k);
+        __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f").delete(folderKey);
+    }
+    async renameFolder(tenantId, shardId, oldPath, newPath) {
+        const oldFolderKey = compositeKey(tenantId, shardId, oldPath);
+        const newFolderKey = compositeKey(tenantId, shardId, newPath);
+        const oldDocPrefix = oldFolderKey + '/';
+        const oldHasExplicit = __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f").has(oldFolderKey);
+        const oldHasImplicit = [...__classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").keys()].some((k) => k.startsWith(oldDocPrefix)) ||
+            [...__classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f")].some((k) => k.startsWith(oldDocPrefix));
+        if (!oldHasExplicit && !oldHasImplicit) {
+            throw new Error(`Cannot rename folder ${oldPath}: does not exist`);
+        }
+        const newDocPrefix = newFolderKey + '/';
+        const newHasExplicit = __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f").has(newFolderKey);
+        const newHasImplicit = [...__classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").keys()].some((k) => k.startsWith(newDocPrefix)) ||
+            [...__classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f")].some((k) => k.startsWith(newDocPrefix));
+        if (newHasExplicit || newHasImplicit) {
+            throw new Error(`Cannot rename folder to ${newPath}: already exists`);
+        }
+        // Rewrite docs
+        const docMoves = [];
+        for (const [key, entry] of __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f")) {
+            if (key.startsWith(oldDocPrefix)) {
+                const rewritten = newFolderKey + '/' + key.slice(oldDocPrefix.length);
+                docMoves.push([key, rewritten, entry]);
+            }
+        }
+        for (const [oldKey, newKey, entry] of docMoves) {
+            __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").delete(oldKey);
+            __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").set(newKey, Object.assign(Object.assign({}, entry), { lastModified: Date.now() }));
+        }
+        // Rewrite folders
+        const folderMoves = [];
+        for (const key of __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f")) {
+            if (key === oldFolderKey) {
+                folderMoves.push([key, newFolderKey]);
+            }
+            else if (key.startsWith(oldDocPrefix)) {
+                folderMoves.push([key, newFolderKey + '/' + key.slice(oldDocPrefix.length)]);
+            }
+        }
+        for (const [oldKey, newKey] of folderMoves) {
+            __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f").delete(oldKey);
+            __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f").add(newKey);
+        }
+    }
+    async listFolders(tenantId, shardId, prefix) {
+        const basePrefix = prefix
+            ? compositeKey(tenantId, shardId, prefix) + '/'
+            : keyPrefix(tenantId, shardId);
+        const out = new Set();
+        for (const key of __classPrivateFieldGet(this, _MemoryDocumentBackend_folders, "f")) {
+            if (!key.startsWith(basePrefix))
+                continue;
+            const rest = key.slice(basePrefix.length);
+            const slash = rest.indexOf('/');
+            out.add(slash >= 0 ? rest.slice(0, slash) : rest);
+        }
+        for (const key of __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").keys()) {
+            if (!key.startsWith(basePrefix))
+                continue;
+            const rest = key.slice(basePrefix.length);
+            const slash = rest.indexOf('/');
+            if (slash >= 0)
+                out.add(rest.slice(0, slash));
+        }
+        return [...out].sort();
+    }
 }
-_MemoryDocumentBackend_store = new WeakMap();
+_MemoryDocumentBackend_store = new WeakMap(), _MemoryDocumentBackend_folders = new WeakMap();
 // ---------------------------------------------------------------------------
 // IndexedDBDocumentBackend
 // ---------------------------------------------------------------------------
 const IDB_NAME = 'sh3-documents';
 const IDB_STORE = 'docs';
-const IDB_VERSION = 2;
+const IDB_FOLDERS = 'folders';
+const IDB_VERSION = 3;
 export class IndexedDBDocumentBackend {
     constructor() {
         _IndexedDBDocumentBackend_instances.add(this);
@@ -274,6 +372,123 @@ export class IndexedDBDocumentBackend {
             req.onerror = () => reject(req.error);
         });
     }
+    async mkdir(tenantId, shardId, path) {
+        const docKey = compositeKey(tenantId, shardId, path);
+        const exists = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readonly', (s) => s.getKey(docKey));
+        if (exists !== undefined) {
+            throw new Error(`Cannot mkdir ${path}: a document occupies this path`);
+        }
+        await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_txOn).call(this, IDB_FOLDERS, 'readwrite', (s) => s.put(1, docKey));
+    }
+    async rmdir(tenantId, shardId, path, opts) {
+        const folderKey = compositeKey(tenantId, shardId, path);
+        const docPrefix = folderKey + '/';
+        const upper = docPrefix + '￿';
+        const docKeys = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(docPrefix, upper, false, false)));
+        const folderKeys = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_txOn).call(this, IDB_FOLDERS, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(docPrefix, upper, false, false)));
+        if (!opts.recursive && (docKeys.length > 0 || folderKeys.length > 0)) {
+            throw new Error(`Cannot rmdir ${path}: folder is not empty`);
+        }
+        const db = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this);
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction([IDB_STORE, IDB_FOLDERS], 'readwrite');
+            const docStore = tx.objectStore(IDB_STORE);
+            const folderStore = tx.objectStore(IDB_FOLDERS);
+            for (const k of docKeys)
+                docStore.delete(k);
+            for (const k of folderKeys)
+                folderStore.delete(k);
+            folderStore.delete(folderKey);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async renameFolder(tenantId, shardId, oldPath, newPath) {
+        const oldFolderKey = compositeKey(tenantId, shardId, oldPath);
+        const newFolderKey = compositeKey(tenantId, shardId, newPath);
+        const oldPrefix = oldFolderKey + '/';
+        const newPrefix = newFolderKey + '/';
+        const upperOld = oldPrefix + '￿';
+        const upperNew = newPrefix + '￿';
+        const [oldDocs, oldFolders, oldExplicit, newDocs, newFolders, newExplicit] = await Promise.all([
+            __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(oldPrefix, upperOld, false, false))),
+            __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_txOn).call(this, IDB_FOLDERS, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(oldPrefix, upperOld, false, false))),
+            __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_txOn).call(this, IDB_FOLDERS, 'readonly', (s) => s.getKey(oldFolderKey)),
+            __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(newPrefix, upperNew, false, false))),
+            __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_txOn).call(this, IDB_FOLDERS, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(newPrefix, upperNew, false, false))),
+            __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_txOn).call(this, IDB_FOLDERS, 'readonly', (s) => s.getKey(newFolderKey)),
+        ]);
+        if (oldDocs.length === 0 && oldFolders.length === 0 && oldExplicit === undefined) {
+            throw new Error(`Cannot rename folder ${oldPath}: does not exist`);
+        }
+        if (newDocs.length > 0 || newFolders.length > 0 || newExplicit !== undefined) {
+            throw new Error(`Cannot rename folder to ${newPath}: already exists`);
+        }
+        // Read doc entries with values via cursor
+        const docEntries = await new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this).then((db) => {
+                const tx = db.transaction(IDB_STORE, 'readonly');
+                const store = tx.objectStore(IDB_STORE);
+                const req = store.openCursor(IDBKeyRange.bound(oldPrefix, upperOld, false, false));
+                const acc = [];
+                req.onsuccess = () => {
+                    const cursor = req.result;
+                    if (cursor) {
+                        acc.push({ key: cursor.key, value: cursor.value });
+                        cursor.continue();
+                    }
+                    else {
+                        resolve(acc);
+                    }
+                };
+                req.onerror = () => reject(req.error);
+            });
+        });
+        const db = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this);
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction([IDB_STORE, IDB_FOLDERS], 'readwrite');
+            const docStore = tx.objectStore(IDB_STORE);
+            const folderStore = tx.objectStore(IDB_FOLDERS);
+            for (const { key, value } of docEntries) {
+                const rewritten = newFolderKey + '/' + key.slice(oldPrefix.length);
+                docStore.delete(key);
+                docStore.put(Object.assign(Object.assign({}, value), { lastModified: Date.now() }), rewritten);
+            }
+            if (oldExplicit !== undefined) {
+                folderStore.delete(oldFolderKey);
+            }
+            folderStore.put(1, newFolderKey);
+            for (const k of oldFolders) {
+                const oldKeyStr = k;
+                const rewritten = newFolderKey + '/' + oldKeyStr.slice(oldPrefix.length);
+                folderStore.delete(k);
+                folderStore.put(1, rewritten);
+            }
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async listFolders(tenantId, shardId, prefix) {
+        const basePrefix = prefix
+            ? compositeKey(tenantId, shardId, prefix) + '/'
+            : keyPrefix(tenantId, shardId);
+        const upper = basePrefix + '￿';
+        const out = new Set();
+        const folderKeys = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_txOn).call(this, IDB_FOLDERS, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(basePrefix, upper, false, false)));
+        for (const k of folderKeys) {
+            const rest = k.slice(basePrefix.length);
+            const slash = rest.indexOf('/');
+            out.add(slash >= 0 ? rest.slice(0, slash) : rest);
+        }
+        const docKeys = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(basePrefix, upper, false, false)));
+        for (const k of docKeys) {
+            const rest = k.slice(basePrefix.length);
+            const slash = rest.indexOf('/');
+            if (slash >= 0)
+                out.add(rest.slice(0, slash));
+        }
+        return [...out].sort();
+    }
 }
 _IndexedDBDocumentBackend_dbPromise = new WeakMap(), _IndexedDBDocumentBackend_instances = new WeakSet(), _IndexedDBDocumentBackend_db = function _IndexedDBDocumentBackend_db() {
     if (!__classPrivateFieldGet(this, _IndexedDBDocumentBackend_dbPromise, "f")) {
@@ -284,6 +499,9 @@ _IndexedDBDocumentBackend_dbPromise = new WeakMap(), _IndexedDBDocumentBackend_i
                 if (!db.objectStoreNames.contains(IDB_STORE)) {
                     db.createObjectStore(IDB_STORE);
                 }
+                if (!db.objectStoreNames.contains(IDB_FOLDERS)) {
+                    db.createObjectStore(IDB_FOLDERS);
+                }
             };
             req.onsuccess = () => resolve(req.result);
             req.onerror = () => reject(req.error);
@@ -301,4 +519,13 @@ async function _IndexedDBDocumentBackend_tx(mode, fn) {
         req.onsuccess = () => resolve(req.result);
         req.onerror = () => reject(req.error);
     });
+}, _IndexedDBDocumentBackend_txOn = async function _IndexedDBDocumentBackend_txOn(storeName, mode, fn) {
+    const db = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this);
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, mode);
+        const store = tx.objectStore(storeName);
+        const req = fn(store);
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
 };

package/dist/documents/backends.test.js

@@ -1,5 +1,5 @@
 import 'fake-indexeddb/auto';
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeEach } from 'vitest';
 import { MemoryDocumentBackend, IndexedDBDocumentBackend } from './backends';
 describe('DocumentBackend tenant-wide primitives', () => {
     it('listAllShards returns every shard that has content for a tenant', async () => {
@@ -99,3 +99,149 @@ describe('IndexedDBDocumentBackend.rename', () => {
             .rejects.toThrow(/not found/);
     });
 });
+describe('MemoryDocumentBackend folder ops', () => {
+    let backend;
+    beforeEach(() => { backend = new MemoryDocumentBackend(); });
+    it('mkdir creates an empty folder visible via listFolders', async () => {
+        await backend.mkdir('t', 's', 'a');
+        expect(await backend.listFolders('t', 's', '')).toEqual(['a']);
+    });
+    it('mkdir is a no-op if the folder already exists', async () => {
+        await backend.mkdir('t', 's', 'a');
+        await backend.mkdir('t', 's', 'a');
+        expect(await backend.listFolders('t', 's', '')).toEqual(['a']);
+    });
+    it('mkdir throws if a document occupies the path', async () => {
+        await backend.write('t', 's', 'a', 'content');
+        await expect(backend.mkdir('t', 's', 'a')).rejects.toThrow();
+    });
+    it('listFolders surfaces folders implied by document paths', async () => {
+        await backend.write('t', 's', 'sub/a.md', 'x');
+        expect(await backend.listFolders('t', 's', '')).toEqual(['sub']);
+    });
+    it('listFolders merges explicit and implicit folders without duplicates', async () => {
+        await backend.mkdir('t', 's', 'sub');
+        await backend.write('t', 's', 'sub/a.md', 'x');
+        expect(await backend.listFolders('t', 's', '')).toEqual(['sub']);
+    });
+    it('listFolders with prefix returns immediate children', async () => {
+        await backend.mkdir('t', 's', 'a/b');
+        await backend.mkdir('t', 's', 'a/c');
+        await backend.write('t', 's', 'a/d/x.md', 'x');
+        const children = await backend.listFolders('t', 's', 'a');
+        expect(children.sort()).toEqual(['b', 'c', 'd']);
+    });
+    it('rmdir on non-empty folder without recursive throws', async () => {
+        await backend.write('t', 's', 'a/x.md', 'x');
+        await expect(backend.rmdir('t', 's', 'a', { recursive: false })).rejects.toThrow();
+    });
+    it('rmdir on empty folder without recursive succeeds', async () => {
+        await backend.mkdir('t', 's', 'a');
+        await backend.rmdir('t', 's', 'a', { recursive: false });
+        expect(await backend.listFolders('t', 's', '')).toEqual([]);
+    });
+    it('rmdir recursive removes folder and all descendants', async () => {
+        await backend.write('t', 's', 'a/x.md', 'x');
+        await backend.write('t', 's', 'a/b/y.md', 'y');
+        await backend.mkdir('t', 's', 'a/empty');
+        await backend.rmdir('t', 's', 'a', { recursive: true });
+        expect(await backend.listFolders('t', 's', '')).toEqual([]);
+        expect(await backend.list('t', 's')).toEqual([]);
+    });
+    it('renameFolder rewrites all descendant doc paths', async () => {
+        await backend.write('t', 's', 'old/x.md', 'x');
+        await backend.write('t', 's', 'old/sub/y.md', 'y');
+        await backend.renameFolder('t', 's', 'old', 'new');
+        const docs = (await backend.list('t', 's')).map((d) => d.path).sort();
+        expect(docs).toEqual(['new/sub/y.md', 'new/x.md']);
+    });
+    it('renameFolder rewrites empty subfolders too', async () => {
+        await backend.mkdir('t', 's', 'old/empty');
+        await backend.renameFolder('t', 's', 'old', 'new');
+        expect((await backend.listFolders('t', 's', 'new')).sort()).toEqual(['empty']);
+    });
+    it('renameFolder throws if newPath already exists', async () => {
+        await backend.mkdir('t', 's', 'a');
+        await backend.mkdir('t', 's', 'b');
+        await expect(backend.renameFolder('t', 's', 'a', 'b')).rejects.toThrow();
+    });
+    it('renameFolder throws if oldPath does not exist', async () => {
+        await expect(backend.renameFolder('t', 's', 'missing', 'b')).rejects.toThrow();
+    });
+});
+describe('IndexedDBDocumentBackend folder ops', () => {
+    let backend;
+    let t;
+    let s;
+    beforeEach(() => {
+        backend = new IndexedDBDocumentBackend();
+        t = 'tenant_' + Math.random().toString(36).slice(2, 10);
+        s = 'shard_' + Math.random().toString(36).slice(2, 10);
+    });
+    it('mkdir creates an empty folder visible via listFolders', async () => {
+        await backend.mkdir(t, s, 'a');
+        expect(await backend.listFolders(t, s, '')).toEqual(['a']);
+    });
+    it('mkdir is a no-op if the folder already exists', async () => {
+        await backend.mkdir(t, s, 'a');
+        await backend.mkdir(t, s, 'a');
+        expect(await backend.listFolders(t, s, '')).toEqual(['a']);
+    });
+    it('mkdir throws if a document occupies the path', async () => {
+        await backend.write(t, s, 'a', 'content');
+        await expect(backend.mkdir(t, s, 'a')).rejects.toThrow();
+    });
+    it('listFolders surfaces folders implied by document paths', async () => {
+        await backend.write(t, s, 'sub/a.md', 'x');
+        expect(await backend.listFolders(t, s, '')).toEqual(['sub']);
+    });
+    it('listFolders merges explicit and implicit folders without duplicates', async () => {
+        await backend.mkdir(t, s, 'sub');
+        await backend.write(t, s, 'sub/a.md', 'x');
+        expect(await backend.listFolders(t, s, '')).toEqual(['sub']);
+    });
+    it('listFolders with prefix returns immediate children', async () => {
+        await backend.mkdir(t, s, 'a/b');
+        await backend.mkdir(t, s, 'a/c');
+        await backend.write(t, s, 'a/d/x.md', 'x');
+        const children = await backend.listFolders(t, s, 'a');
+        expect(children.sort()).toEqual(['b', 'c', 'd']);
+    });
+    it('rmdir on non-empty folder without recursive throws', async () => {
+        await backend.write(t, s, 'a/x.md', 'x');
+        await expect(backend.rmdir(t, s, 'a', { recursive: false })).rejects.toThrow();
+    });
+    it('rmdir on empty folder without recursive succeeds', async () => {
+        await backend.mkdir(t, s, 'a');
+        await backend.rmdir(t, s, 'a', { recursive: false });
+        expect(await backend.listFolders(t, s, '')).toEqual([]);
+    });
+    it('rmdir recursive removes folder and all descendants', async () => {
+        await backend.write(t, s, 'a/x.md', 'x');
+        await backend.write(t, s, 'a/b/y.md', 'y');
+        await backend.mkdir(t, s, 'a/empty');
+        await backend.rmdir(t, s, 'a', { recursive: true });
+        expect(await backend.listFolders(t, s, '')).toEqual([]);
+        expect(await backend.list(t, s)).toEqual([]);
+    });
+    it('renameFolder rewrites all descendant doc paths', async () => {
+        await backend.write(t, s, 'old/x.md', 'x');
+        await backend.write(t, s, 'old/sub/y.md', 'y');
+        await backend.renameFolder(t, s, 'old', 'new');
+        const docs = (await backend.list(t, s)).map((d) => d.path).sort();
+        expect(docs).toEqual(['new/sub/y.md', 'new/x.md']);
+    });
+    it('renameFolder rewrites empty subfolders too', async () => {
+        await backend.mkdir(t, s, 'old/empty');
+        await backend.renameFolder(t, s, 'old', 'new');
+        expect((await backend.listFolders(t, s, 'new')).sort()).toEqual(['empty']);
+    });
+    it('renameFolder throws if newPath already exists', async () => {
+        await backend.mkdir(t, s, 'a');
+        await backend.mkdir(t, s, 'b');
+        await expect(backend.renameFolder(t, s, 'a', 'b')).rejects.toThrow();
+    });
+    it('renameFolder throws if oldPath does not exist', async () => {
+        await expect(backend.renameFolder(t, s, 'missing', 'b')).rejects.toThrow();
+    });
+});