sh3-core 0.20.1 → 0.20.2

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

@@ -32,4 +32,10 @@ export declare class HttpDocumentBackend implements DocumentBackend {
     } | string): Promise<void>;
     readBranch(tenantId: string, shardId: string, path: string, origin: string): Promise<string | null>;
     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: {
+        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/http-backend.js

@@ -147,6 +147,67 @@ export class HttpDocumentBackend {
             throw new Error(`Document rename failed: ${res.status}`);
         }
     }
+    async mkdir(tenantId, shardId, path) {
+        const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}/mkdir`;
+        const res = await apiFetch(url, {
+            method: 'POST',
+            headers: __classPrivateFieldGet(this, _HttpDocumentBackend_instances, "m", _HttpDocumentBackend_authHeaders).call(this),
+            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 */_a) { /* not JSON */ }
+            throw new Error(`mkdir failed: ${detail}`);
+        }
+    }
+    async rmdir(tenantId, shardId, path, opts) {
+        const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${path}/rmdir`;
+        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({ recursive: opts.recursive }),
+            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 */_a) { /* not JSON */ }
+            throw new Error(`rmdir failed: ${detail}`);
+        }
+    }
+    async renameFolder(tenantId, shardId, oldPath, newPath) {
+        const url = `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${oldPath}/rename-folder`;
+        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({ to: newPath }),
+            credentials: 'include',
+        });
+        if (res.status === 404)
+            throw new Error(`Folder not found at ${oldPath}`);
+        if (res.status === 409)
+            throw new Error(`Folder already exists at ${newPath}`);
+        if (!res.ok)
+            throw new Error(`renameFolder failed: ${res.status}`);
+    }
+    async listFolders(tenantId, shardId, prefix) {
+        const base = prefix
+            ? `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}/${prefix}?folders=1`
+            : `${__classPrivateFieldGet(this, _HttpDocumentBackend_baseUrl, "f")}/api/docs/${tenantId}/${shardId}?folders=1`;
+        const res = await apiFetch(base, { credentials: 'include' });
+        if (!res.ok)
+            throw new Error(`listFolders failed: ${res.status}`);
+        return res.json();
+    }
 }
 _HttpDocumentBackend_baseUrl = new WeakMap(), _HttpDocumentBackend_apiKey = new WeakMap(), _HttpDocumentBackend_instances = new WeakSet(), _HttpDocumentBackend_authHeaders = function _HttpDocumentBackend_authHeaders() {
     if (!__classPrivateFieldGet(this, _HttpDocumentBackend_apiKey, "f"))

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, afterEach } from 'vitest';
+import { describe, it, expect, afterEach, vi } from 'vitest';
 import { HttpDocumentBackend } from './http-backend';
 const originalFetch = globalThis.fetch;
 describe('HttpDocumentBackend.readBranch', () => {
@@ -79,3 +79,53 @@ describe('HttpDocumentBackend.rename', () => {
             .rejects.toThrow(/rename failed/i);
     });
 });
+describe('HttpDocumentBackend folder ops', () => {
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('mkdir POSTs to /:path/mkdir', async () => {
+        const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+        globalThis.fetch = fetchMock;
+        const backend = new HttpDocumentBackend('http://server');
+        await backend.mkdir('t', 's', 'a/b');
+        expect(fetchMock).toHaveBeenCalledWith('http://server/api/docs/t/s/a/b/mkdir', expect.objectContaining({ method: 'POST' }));
+    });
+    it('rmdir POSTs to /:path/rmdir with recursive flag', async () => {
+        const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+        globalThis.fetch = fetchMock;
+        const backend = new HttpDocumentBackend('http://server');
+        await backend.rmdir('t', 's', 'a', { recursive: true });
+        const call = fetchMock.mock.calls[0];
+        expect(call[0]).toBe('http://server/api/docs/t/s/a/rmdir');
+        const body = JSON.parse(call[1].body);
+        expect(body).toEqual({ recursive: true });
+    });
+    it('rmdir throws on 409', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(new Response(JSON.stringify({ error: 'not empty' }), { status: 409 }));
+        const backend = new HttpDocumentBackend('http://server');
+        await expect(backend.rmdir('t', 's', 'a', { recursive: false })).rejects.toThrow();
+    });
+    it('renameFolder POSTs to /:path/rename-folder with { to }', async () => {
+        const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+        globalThis.fetch = fetchMock;
+        const backend = new HttpDocumentBackend('http://server');
+        await backend.renameFolder('t', 's', 'old', 'new');
+        const call = fetchMock.mock.calls[0];
+        expect(call[0]).toBe('http://server/api/docs/t/s/old/rename-folder');
+        expect(JSON.parse(call[1].body)).toEqual({ to: 'new' });
+    });
+    it('listFolders at root uses ?folders=1 on the shard list URL', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(new Response(JSON.stringify(['a', 'b']), { status: 200 }));
+        const backend = new HttpDocumentBackend('http://server');
+        const result = await backend.listFolders('t', 's', '');
+        expect(globalThis.fetch).toHaveBeenCalledWith('http://server/api/docs/t/s?folders=1', expect.any(Object));
+        expect(result).toEqual(['a', 'b']);
+    });
+    it('listFolders with prefix uses ?folders=1 on the path URL', async () => {
+        globalThis.fetch = vi.fn().mockResolvedValue(new Response(JSON.stringify(['c']), { status: 200 }));
+        const backend = new HttpDocumentBackend('http://server');
+        const result = await backend.listFolders('t', 's', 'a');
+        expect(globalThis.fetch).toHaveBeenCalledWith('http://server/api/docs/t/s/a?folders=1', expect.any(Object));
+        expect(result).toEqual(['c']);
+    });
+});

package/dist/documents/picker-api.test.js

@@ -43,7 +43,7 @@ beforeEach(() => {
     vi.clearAllMocks();
 });
 describe('createDocumentPicker', () => {
-    const sampleDoc = { shardId: 'my-shard', path: 'readme.md' };
+    const sampleDoc = { shardId: 'my-shard', path: 'readme.md', kind: 'file' };
     describe('open() — modal (no anchor)', () => {
         it('resolves with OpenerValue when user commits', async () => {
             const listFn = async () => [{ shardId: 'my-shard', path: 'readme.md', size: 100, lastModified: 0 }];
@@ -53,7 +53,7 @@ describe('createDocumentPicker', () => {
             await vi.waitFor(() => expect(mockModalOpen).toHaveBeenCalledOnce());
             modal.commit(sampleDoc);
             const result = await promise;
-            expect(result).toEqual({ shardId: 'my-shard', path: 'readme.md' });
+            expect(result).toEqual({ shardId: 'my-shard', path: 'readme.md', kind: 'file' });
             expect(mockPopupShow).not.toHaveBeenCalled();
         });
         it('resolves with null when user cancels', async () => {

package/dist/documents/types.d.ts

@@ -73,26 +73,37 @@ export interface DocumentMeta {
     deleted?: boolean;
 }
 /** Change notification payload delivered to watch callbacks. */
-export interface DocumentChange {
-    type: 'create' | 'update' | 'delete' | 'rename';
-    /**
-     * For 'create' / 'update' / 'delete', the affected document path.
-     * For 'rename', the new path the document now lives at.
-     */
+export type DocumentChange = {
+    type: 'create' | 'update' | 'delete';
     path: string;
-    /**
-     * Populated only when type === 'rename'. The path the document
-     * used to live at before the rename.
-     */
-    oldPath?: string;
     tenantId: string;
     shardId: string;
-}
-/** Type guard: narrows a DocumentChange to the rename variant. */
-export declare function isRename(change: DocumentChange): change is DocumentChange & {
+} | {
     type: 'rename';
+    path: string;
     oldPath: string;
+    tenantId: string;
+    shardId: string;
+} | {
+    type: 'folder-create' | 'folder-delete';
+    path: string;
+    tenantId: string;
+    shardId: string;
+} | {
+    type: 'folder-rename';
+    path: string;
+    oldPath: string;
+    tenantId: string;
+    shardId: string;
 };
+/** Type guard: narrows a DocumentChange to the rename variant. */
+export declare function isRename(change: DocumentChange): change is Extract<DocumentChange, {
+    type: 'rename';
+}>;
+/** Type guard: narrows a DocumentChange to the folder-rename variant. */
+export declare function isFolderRename(change: DocumentChange): change is Extract<DocumentChange, {
+    type: 'folder-rename';
+}>;
 import type { DocStatus } from './sync-types';
 /**
  * File-oriented backend for the document zone.
@@ -120,6 +131,31 @@ export interface DocumentBackend {
      * as folder semantics.
      */
     rename(tenantId: string, shardId: string, oldPath: string, newPath: string): Promise<void>;
+    /**
+     * Create an empty folder. No-op if the folder already exists.
+     * Throws if a document occupies the path.
+     */
+    mkdir(tenantId: string, shardId: string, path: string): Promise<void>;
+    /**
+     * Remove a folder. Throws if non-empty and `recursive` is false.
+     * When `recursive: true`, atomically removes the folder and all
+     * descendant documents and folders.
+     */
+    rmdir(tenantId: string, shardId: string, path: string, opts: {
+        recursive: boolean;
+    }): Promise<void>;
+    /**
+     * Rename a folder atomically. Rewrites all descendant document paths
+     * to use the new prefix. Throws if `oldPath` does not exist as a
+     * folder, or if `newPath` already exists.
+     */
+    renameFolder(tenantId: string, shardId: string, oldPath: string, newPath: string): Promise<void>;
+    /**
+     * List immediate folder children of `prefix`. Returns folder names
+     * (not full paths). Empty `prefix` lists folders directly under the
+     * shard root.
+     */
+    listFolders(tenantId: string, shardId: string, prefix: string): Promise<string[]>;
     /** List all documents stored for this tenant + shard combination. */
     list(tenantId: string, shardId: string): Promise<DocumentMeta[]>;
     /** Return true if the document at `path` exists. */
@@ -187,6 +223,32 @@ export interface DocumentHandle {
      * extensions filter — newPath must satisfy the filter.
      */
     rename(oldPath: string, newPath: string, opts?: ScopeOption): Promise<void>;
+    /**
+     * Create an empty folder at `path`. No-op if the folder already
+     * exists. Throws if a document occupies the path.
+     */
+    mkdir(path: string, opts?: ScopeOption): Promise<void>;
+    /**
+     * Remove a folder. Throws if non-empty and `opts.recursive` is not
+     * true. When `opts.recursive` is true, atomically removes the folder
+     * and all descendants. Throws if any active autosave controller's
+     * path falls inside the folder.
+     */
+    rmdir(path: string, opts?: {
+        recursive?: boolean;
+    } & ScopeOption): Promise<void>;
+    /**
+     * Rename a folder. Atomically rewrites all descendant document paths.
+     * Throws if any active autosave controller's path falls inside the
+     * folder (caller must flush and dispose first). Throws if `newPath`
+     * already exists or if `oldPath` does not.
+     */
+    renameFolder(oldPath: string, newPath: string, opts?: ScopeOption): Promise<void>;
+    /**
+     * List immediate folder children of `prefix`. Empty `prefix` (or
+     * omitted) lists folders directly under the shard root.
+     */
+    listFolders(prefix?: string, opts?: ScopeOption): Promise<string[]>;
     /** Check existence without reading content. */
     exists(path: string): Promise<boolean>;
     /** Fetch sync-state metadata for a path. Null if the doc does not exist. */

package/dist/documents/types.js

@@ -51,3 +51,7 @@ export const PERMISSION_DOCUMENTS_MOUNT = 'documents:mount';
 export function isRename(change) {
     return change.type === 'rename';
 }
+/** Type guard: narrows a DocumentChange to the folder-rename variant. */
+export function isFolderRename(change) {
+    return change.type === 'folder-rename';
+}

package/dist/primitives/widgets/DocumentFilePicker.d.ts

@@ -2,7 +2,11 @@ import type { DocumentMeta } from '../../documents/types';
 export type DocEntry = DocumentMeta & {
     shardId: string;
 };
-export type OpenerValue = Pick<DocEntry, 'shardId' | 'path'> | null;
+export type OpenerValue = {
+    shardId: string;
+    path: string;
+    kind: 'file' | 'folder';
+} | null;
 export type SaverValue = string | null;
 export type FileItem = {
     kind: 'folder';
@@ -13,7 +17,7 @@ export type FileItem = {
     name: string;
     doc: DocEntry;
 };
-export declare function buildTree(docs: DocEntry[], shardId: string | null, prefix: string): FileItem[];
+export declare function buildTree(docs: DocEntry[], folders: string[], shardId: string | null, prefix: string): FileItem[];
 export declare function formatSize(bytes: number): string;
 export declare function formatDate(epochMs: number): string;
 export declare function iconForFile(name: string): string;

package/dist/primitives/widgets/DocumentFilePicker.js

@@ -1,10 +1,10 @@
-export function buildTree(docs, shardId, prefix) {
+export function buildTree(docs, folders, shardId, prefix) {
     if (shardId === null) {
         const shards = [...new Set(docs.map((d) => d.shardId))].sort();
         return shards.map((s) => ({ kind: 'folder', name: s, fullPath: s }));
     }
     const shardDocs = docs.filter((d) => d.shardId === shardId);
-    const folders = new Map();
+    const folderMap = new Map();
     const files = [];
     const normPrefix = prefix ? prefix + '/' : '';
     const plen = normPrefix.length;
@@ -16,14 +16,21 @@ export function buildTree(docs, shardId, prefix) {
         if (slash >= 0) {
             const name = relative.slice(0, slash);
             const full = prefix ? `${prefix}/${name}` : name;
-            if (!folders.has(name))
-                folders.set(name, full);
+            if (!folderMap.has(name))
+                folderMap.set(name, full);
         }
         else {
             files.push({ kind: 'file', name: relative, doc });
         }
     }
-    const folderItems = [...folders.entries()]
+    // Merge explicit empty folders (immediate children of prefix)
+    for (const name of folders) {
+        if (folderMap.has(name))
+            continue;
+        const full = prefix ? `${prefix}/${name}` : name;
+        folderMap.set(name, full);
+    }
+    const folderItems = [...folderMap.entries()]
         .map(([name, fullPath]) => ({ kind: 'folder', name, fullPath }))
         .sort((a, b) => a.name.localeCompare(b.name));
     const fileItems = files.sort((a, b) => a.name.localeCompare(b.name));

package/dist/primitives/widgets/DocumentFilePicker.svelte

@@ -6,24 +6,40 @@
   import type { DocEntry, OpenerValue, SaverValue } from './DocumentFilePicker';
 
   type DocListFn = () => Promise<Array<DocumentMeta & { shardId: string }>>;
+  type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
+  type HandleFn = {
+    mkdir: (shardId: string, path: string) => Promise<void>;
+    rmdir: (shardId: string, path: string, opts: { recursive: boolean }) => Promise<void>;
+    renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    delete: (shardId: string, path: string) => Promise<void>;
+  };
 
   let {
     mode,
     value = $bindable<OpenerValue | SaverValue>(null),
     listDocuments,
+    listFolders,
+    handle,
+    readOnlyShard,
     disabled = false,
     invalid = false,
     size = 'md',
     buttonLabel = 'Choose…',
+    selectable = 'file',
     onchange,
   }: {
     mode: 'open' | 'save';
     value?: OpenerValue | SaverValue;
     listDocuments: DocListFn;
+    listFolders?: FolderListFn;
+    handle?: HandleFn;
+    readOnlyShard?: (shardId: string) => boolean;
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';
     buttonLabel?: string;
+    selectable?: 'file' | 'folder' | 'both';
   } & CommitOnlyEvents<OpenerValue | SaverValue> = $props();
 
   let trigger = $state<HTMLButtonElement | undefined>(undefined);
@@ -33,7 +49,9 @@
     value
       ? typeof value === 'string'
         ? value
-        : `${value.shardId}/${value.path}`
+        : value.kind === 'folder'
+          ? `${value.shardId}/${value.path}/`
+          : `${value.shardId}/${value.path}`
       : null,
   );
 
@@ -63,6 +81,10 @@
       {
         mode,
         docs,
+        selectable,
+        listFolders,
+        handle,
+        readOnlyShard,
         onCommit: (result: OpenerValue | SaverValue) => {
           handleCommit(result);
         },

package/dist/primitives/widgets/DocumentFilePicker.svelte.d.ts

@@ -4,14 +4,28 @@ import type { OpenerValue, SaverValue } from './DocumentFilePicker';
 type DocListFn = () => Promise<Array<DocumentMeta & {
     shardId: string;
 }>>;
+type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
+type HandleFn = {
+    mkdir: (shardId: string, path: string) => Promise<void>;
+    rmdir: (shardId: string, path: string, opts: {
+        recursive: boolean;
+    }) => Promise<void>;
+    renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    delete: (shardId: string, path: string) => Promise<void>;
+};
 type $$ComponentProps = {
     mode: 'open' | 'save';
     value?: OpenerValue | SaverValue;
     listDocuments: DocListFn;
+    listFolders?: FolderListFn;
+    handle?: HandleFn;
+    readOnlyShard?: (shardId: string) => boolean;
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';
     buttonLabel?: string;
+    selectable?: 'file' | 'folder' | 'both';
 } & CommitOnlyEvents<OpenerValue | SaverValue>;
 declare const DocumentFilePicker: import("svelte").Component<$$ComponentProps, {}, "value">;
 type DocumentFilePicker = ReturnType<typeof DocumentFilePicker>;

package/dist/primitives/widgets/DocumentFilePicker.test.d.ts

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

package/dist/primitives/widgets/DocumentFilePicker.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { buildTree } from './DocumentFilePicker';
+describe('buildTree with explicit folders', () => {
+    const docs = [
+        { shardId: 'sh1', path: 'a.md', size: 0, lastModified: 0 },
+        { shardId: 'sh1', path: 'sub/b.md', size: 0, lastModified: 0 },
+    ];
+    it('shard root returns shard list (folders ignored at root)', () => {
+        const items = buildTree(docs, [], null, '');
+        expect(items.map((i) => i.kind === 'folder' && i.name)).toEqual(['sh1']);
+    });
+    it('within a shard, merges implicit folders with empty explicit folders', () => {
+        const items = buildTree(docs, ['emptyDir'], 'sh1', '');
+        const folderNames = items.filter((i) => i.kind === 'folder').map((i) => i.name).sort();
+        expect(folderNames).toEqual(['emptyDir', 'sub']);
+    });
+    it('deduplicates explicit and implicit folders with the same name', () => {
+        const items = buildTree(docs, ['sub'], 'sh1', '');
+        const folderNames = items.filter((i) => i.kind === 'folder').map((i) => i.name);
+        expect(folderNames).toEqual(['sub']);
+    });
+    it('file items carry kind:"file"', () => {
+        const items = buildTree(docs, [], 'sh1', '');
+        const fileItems = items.filter((i) => i.kind === 'file');
+        expect(fileItems[0]).toMatchObject({ kind: 'file', name: 'a.md' });
+    });
+});
+describe('OpenerValue type accepts folder kind', () => {
+    it('compiles with kind:"folder"', () => {
+        const v = { shardId: 'sh1', path: 'sub', kind: 'folder' };
+        expect(v === null || v === void 0 ? void 0 : v.kind).toBe('folder');
+    });
+});

package/dist/primitives/widgets/DocumentOpener.svelte

@@ -5,10 +5,22 @@
   import type { OpenerValue } from './DocumentFilePicker';
 
   type DocListFn = () => Promise<Array<DocumentMeta & { shardId: string }>>;
+  type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
+  type HandleFn = {
+    mkdir: (shardId: string, path: string) => Promise<void>;
+    rmdir: (shardId: string, path: string, opts: { recursive: boolean }) => Promise<void>;
+    renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    delete: (shardId: string, path: string) => Promise<void>;
+  };
 
   let {
     value = $bindable<OpenerValue>(null),
     listDocuments,
+    listFolders,
+    handle,
+    readOnlyShard,
+    selectable = 'file',
     disabled = false,
     invalid = false,
     size = 'md',
@@ -17,6 +29,10 @@
   }: {
     value?: OpenerValue;
     listDocuments: DocListFn;
+    listFolders?: FolderListFn;
+    handle?: HandleFn;
+    readOnlyShard?: (shardId: string) => boolean;
+    selectable?: 'file' | 'folder' | 'both';
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';
@@ -28,6 +44,10 @@
   mode="open"
   bind:value
   {listDocuments}
+  {listFolders}
+  {handle}
+  {readOnlyShard}
+  {selectable}
   {disabled}
   {invalid}
   {size}

package/dist/primitives/widgets/DocumentOpener.svelte.d.ts

@@ -4,9 +4,23 @@ import type { OpenerValue } from './DocumentFilePicker';
 type DocListFn = () => Promise<Array<DocumentMeta & {
     shardId: string;
 }>>;
+type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
+type HandleFn = {
+    mkdir: (shardId: string, path: string) => Promise<void>;
+    rmdir: (shardId: string, path: string, opts: {
+        recursive: boolean;
+    }) => Promise<void>;
+    renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    delete: (shardId: string, path: string) => Promise<void>;
+};
 type $$ComponentProps = {
     value?: OpenerValue;
     listDocuments: DocListFn;
+    listFolders?: FolderListFn;
+    handle?: HandleFn;
+    readOnlyShard?: (shardId: string) => boolean;
+    selectable?: 'file' | 'folder' | 'both';
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';

package/dist/primitives/widgets/DocumentSaver.svelte

@@ -5,10 +5,21 @@
   import type { SaverValue } from './DocumentFilePicker';
 
   type DocListFn = () => Promise<Array<DocumentMeta & { shardId: string }>>;
+  type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
+  type HandleFn = {
+    mkdir: (shardId: string, path: string) => Promise<void>;
+    rmdir: (shardId: string, path: string, opts: { recursive: boolean }) => Promise<void>;
+    renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    delete: (shardId: string, path: string) => Promise<void>;
+  };
 
   let {
     value = $bindable<SaverValue>(null),
     listDocuments,
+    listFolders,
+    handle,
+    readOnlyShard,
     disabled = false,
     invalid = false,
     size = 'md',
@@ -17,6 +28,9 @@
   }: {
     value?: SaverValue;
     listDocuments: DocListFn;
+    listFolders?: FolderListFn;
+    handle?: HandleFn;
+    readOnlyShard?: (shardId: string) => boolean;
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';
@@ -28,6 +42,9 @@
   mode="save"
   bind:value
   {listDocuments}
+  {listFolders}
+  {handle}
+  {readOnlyShard}
   {disabled}
   {invalid}
   {size}

package/dist/primitives/widgets/DocumentSaver.svelte.d.ts

@@ -4,9 +4,22 @@ import type { SaverValue } from './DocumentFilePicker';
 type DocListFn = () => Promise<Array<DocumentMeta & {
     shardId: string;
 }>>;
+type FolderListFn = (shardId: string, prefix: string) => Promise<string[]>;
+type HandleFn = {
+    mkdir: (shardId: string, path: string) => Promise<void>;
+    rmdir: (shardId: string, path: string, opts: {
+        recursive: boolean;
+    }) => Promise<void>;
+    renameFolder: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    rename: (shardId: string, oldPath: string, newPath: string) => Promise<void>;
+    delete: (shardId: string, path: string) => Promise<void>;
+};
 type $$ComponentProps = {
     value?: SaverValue;
     listDocuments: DocListFn;
+    listFolders?: FolderListFn;
+    handle?: HandleFn;
+    readOnlyShard?: (shardId: string) => boolean;
     disabled?: boolean;
     invalid?: boolean;
     size?: 'sm' | 'md';