sh3-core 0.6.0

package/dist/build.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Build-time helpers for SH3 package authors.
+ *
+ * Usage in a downstream vite.config.ts:
+ *
+ *   import { svelte } from '@sveltejs/vite-plugin-svelte';
+ *   import { sh3CssInline } from 'sh3-core/build';
+ *
+ *   export default defineConfig({
+ *     plugins: [svelte(), sh3CssInline()],
+ *     build: {
+ *       lib: { entry: 'src/main.ts', formats: ['es'], fileName: 'bundle' },
+ *       rollupOptions: {
+ *         external: ['sh3', 'svelte', 'svelte/internal/client'],
+ *       },
+ *     },
+ *   });
+ */
+import type { Plugin } from 'vite';
+import type { ArtifactManifest } from './artifact';
+/**
+ * Vite plugin that inlines extracted CSS into the JS bundle.
+ *
+ * Vite's lib mode writes CSS to a separate file outside the Rollup
+ * bundle pipeline, so Rollup hooks like `generateBundle` never see it.
+ * This plugin uses `closeBundle` — which runs after all files are on
+ * disk — to find CSS files, inject their contents into the JS entry
+ * as a self-executing `<style>` injector, and delete the CSS files.
+ */
+export declare function sh3CssInline(): Plugin;
+/**
+ * Options for the sh3Artifact plugin.
+ */
+export interface Sh3ArtifactOptions {
+    /** Path to pre-built server bundle. If provided, gets copied as server.js. */
+    serverEntry?: string;
+    /** Override manifest fields not extractable from code (description, author, requires). */
+    manifest?: Partial<Pick<ArtifactManifest, 'description' | 'author' | 'requires'>>;
+}
+/**
+ * Vite plugin that produces a distributable artifact directory after build.
+ *
+ * After Vite's lib build completes, this plugin:
+ *   1. Finds the entry chunk and renames it to client.js
+ *   2. Optionally copies a pre-built server bundle as server.js
+ *   3. Extracts manifest fields (id, label, version, type) from the source
+ *   4. Writes manifest.json alongside the bundles
+ */
+export declare function sh3Artifact(options?: Sh3ArtifactOptions): Plugin;

package/dist/build.js

@@ -0,0 +1,236 @@
+/**
+ * Build-time helpers for SH3 package authors.
+ *
+ * Usage in a downstream vite.config.ts:
+ *
+ *   import { svelte } from '@sveltejs/vite-plugin-svelte';
+ *   import { sh3CssInline } from 'sh3-core/build';
+ *
+ *   export default defineConfig({
+ *     plugins: [svelte(), sh3CssInline()],
+ *     build: {
+ *       lib: { entry: 'src/main.ts', formats: ['es'], fileName: 'bundle' },
+ *       rollupOptions: {
+ *         external: ['sh3', 'svelte', 'svelte/internal/client'],
+ *       },
+ *     },
+ *   });
+ */
+import { readFileSync, writeFileSync, unlinkSync, readdirSync, copyFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Vite plugin that inlines extracted CSS into the JS bundle.
+ *
+ * Vite's lib mode writes CSS to a separate file outside the Rollup
+ * bundle pipeline, so Rollup hooks like `generateBundle` never see it.
+ * This plugin uses `closeBundle` — which runs after all files are on
+ * disk — to find CSS files, inject their contents into the JS entry
+ * as a self-executing `<style>` injector, and delete the CSS files.
+ */
+export function sh3CssInline() {
+    let resolvedConfig;
+    return {
+        name: 'sh3-css-inline',
+        apply: 'build',
+        enforce: 'post',
+        configResolved(config) {
+            resolvedConfig = config;
+        },
+        closeBundle() {
+            const outDir = resolvedConfig.build.outDir;
+            // Find all .css and .js files in the output directory.
+            let files;
+            try {
+                files = readdirSync(outDir);
+            }
+            catch (_a) {
+                return;
+            }
+            const cssFiles = files.filter(f => f.endsWith('.css'));
+            const jsFiles = files.filter(f => f.endsWith('.js'));
+            if (cssFiles.length === 0 || jsFiles.length === 0)
+                return;
+            // Read and concatenate all CSS.
+            const cssChunks = [];
+            for (const cssFile of cssFiles) {
+                const content = readFileSync(join(outDir, cssFile), 'utf-8').trim();
+                if (content)
+                    cssChunks.push(content);
+            }
+            if (cssChunks.length === 0)
+                return;
+            // Build a JS snippet that injects a <style> tag at load time.
+            const combined = cssChunks.join('\n');
+            const escaped = JSON.stringify(combined);
+            const injector = [
+                '/* sh3-css-inline: injected styles */',
+                '(function(){',
+                '  const s=document.createElement("style");',
+                `  s.textContent=${escaped};`,
+                '  document.head.appendChild(s);',
+                '})();',
+                '',
+            ].join('\n');
+            // Prepend the injector to the first JS file (the entry).
+            const jsEntry = jsFiles[0];
+            const jsPath = join(outDir, jsEntry);
+            const jsContent = readFileSync(jsPath, 'utf-8');
+            writeFileSync(jsPath, injector + jsContent);
+            // Delete the CSS files.
+            for (const cssFile of cssFiles) {
+                unlinkSync(join(outDir, cssFile));
+            }
+        },
+    };
+}
+/**
+ * Vite plugin that produces a distributable artifact directory after build.
+ *
+ * After Vite's lib build completes, this plugin:
+ *   1. Finds the entry chunk and renames it to client.js
+ *   2. Optionally copies a pre-built server bundle as server.js
+ *   3. Extracts manifest fields (id, label, version, type) from the source
+ *   4. Writes manifest.json alongside the bundles
+ */
+export function sh3Artifact(options = {}) {
+    let outDir = '';
+    let entryFileName = '';
+    return {
+        name: 'sh3-artifact',
+        apply: 'build',
+        enforce: 'post',
+        configResolved(config) {
+            outDir = config.build.outDir;
+        },
+        generateBundle(_outputOptions, bundle) {
+            // Find the entry chunk — the one Rollup marks as isEntry.
+            for (const [fileName, chunk] of Object.entries(bundle)) {
+                if (chunk.type === 'chunk' && chunk.isEntry) {
+                    entryFileName = fileName;
+                    break;
+                }
+            }
+        },
+        async closeBundle() {
+            var _a, _b, _c, _d, _e;
+            if (!entryFileName)
+                return;
+            const clientSrc = join(outDir, entryFileName);
+            const clientDest = join(outDir, 'client.js');
+            // Read source before potentially overwriting.
+            let source = '';
+            try {
+                source = readFileSync(clientSrc, 'utf-8');
+            }
+            catch (_f) {
+                console.warn('[sh3-artifact] Could not read entry chunk:', clientSrc);
+                return;
+            }
+            // Rename entry chunk to client.js (only if names differ).
+            if (clientSrc !== clientDest) {
+                writeFileSync(clientDest, source);
+                unlinkSync(clientSrc);
+            }
+            // --- Extract manifest fields from App or Shard block ---
+            //
+            // The bundle may contain both an App manifest (has `requiredShards`)
+            // and a Shard manifest (has `views: [`). We extract id/label/version
+            // from the App block first, then fall back to the Shard block.
+            // If neither block exists, the build fails with a clear error.
+            const hasApp = /\brequiredShards\s*:\s*\[/.test(source);
+            const hasShard = /\bviews\s*:\s*\[/.test(source);
+            if (!hasApp && !hasShard) {
+                throw new Error('[sh3-artifact] Could not find an App manifest (requiredShards) or Shard manifest (views) in the entry chunk. '
+                    + 'Ensure the entry exports an App or Shard object.');
+            }
+            const type = hasShard && hasApp ? 'combo' : hasApp ? 'app' : 'shard';
+            /**
+             * Extract id, label, and version from the manifest object block that
+             * contains `anchor`. Walks backwards from the anchor to find the
+             * opening `{`, then forward to find the matching `}`, and extracts
+             * fields from within that slice.
+             */
+            function extractFromBlock(anchor) {
+                const anchorMatch = anchor.exec(source);
+                if (!anchorMatch)
+                    return null;
+                // Walk backwards from the anchor to find the enclosing `{`.
+                let depth = 0;
+                let blockStart = anchorMatch.index;
+                for (let i = anchorMatch.index - 1; i >= 0; i--) {
+                    if (source[i] === '}')
+                        depth++;
+                    if (source[i] === '{') {
+                        if (depth === 0) {
+                            blockStart = i;
+                            break;
+                        }
+                        depth--;
+                    }
+                }
+                // Walk forwards from the anchor to find the matching `}`.
+                depth = 0;
+                let blockEnd = source.length;
+                for (let i = blockStart; i < source.length; i++) {
+                    if (source[i] === '{')
+                        depth++;
+                    if (source[i] === '}') {
+                        depth--;
+                        if (depth === 0) {
+                            blockEnd = i + 1;
+                            break;
+                        }
+                    }
+                }
+                const block = source.slice(blockStart, blockEnd);
+                const get = (pattern) => {
+                    const m = block.match(pattern);
+                    return m ? m[1] : '';
+                };
+                return {
+                    id: get(/\bid\s*:\s*["']([^"']+)["']/),
+                    label: get(/\blabel\s*:\s*["']([^"']+)["']/),
+                    version: get(/\bversion\s*:\s*["']([^"']+)["']/),
+                };
+            }
+            // App first, then Shard.
+            const extracted = (_a = extractFromBlock(/\brequiredShards\s*:\s*\[/)) !== null && _a !== void 0 ? _a : extractFromBlock(/\bviews\s*:\s*\[/);
+            const { id, label, version } = extracted;
+            // --- Optional server bundle ---
+            let hasServer = false;
+            if (options.serverEntry && existsSync(options.serverEntry)) {
+                copyFileSync(options.serverEntry, join(outDir, 'server.js'));
+                hasServer = true;
+            }
+            // --- Read fallback metadata from package.json ---
+            let pkgDescription;
+            let pkgAuthor;
+            try {
+                const pkg = JSON.parse(readFileSync('package.json', 'utf-8'));
+                pkgDescription = typeof pkg.description === 'string' ? pkg.description : undefined;
+                pkgAuthor = typeof pkg.author === 'string'
+                    ? pkg.author
+                    : typeof ((_b = pkg.author) === null || _b === void 0 ? void 0 : _b.name) === 'string' ? pkg.author.name : undefined;
+            }
+            catch ( /* no package.json or unreadable */_g) { /* no package.json or unreadable */ }
+            // --- Write manifest.json ---
+            const overrides = (_c = options.manifest) !== null && _c !== void 0 ? _c : {};
+            const finalDescription = (_d = overrides.description) !== null && _d !== void 0 ? _d : pkgDescription;
+            const finalAuthor = (_e = overrides.author) !== null && _e !== void 0 ? _e : pkgAuthor;
+            if (!finalDescription) {
+                throw new Error('[sh3-artifact] Missing "description". Add it to package.json or pass it via sh3Artifact({ manifest: { description } }).');
+            }
+            if (!finalAuthor) {
+                throw new Error('[sh3-artifact] Missing "author". Add it to package.json or pass it via sh3Artifact({ manifest: { author } }).');
+            }
+            const manifest = Object.assign(Object.assign(Object.assign({ id: id || 'unknown', type, label: label || id || 'unknown', version: version || '0.0.0', contractVersion: 1, client: 'client.js' }, (hasServer ? { server: 'server.js' } : {})), { description: finalDescription, author: finalAuthor }), overrides);
+            writeFileSync(join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+            // --- Log summary ---
+            const files = ['manifest.json', 'client.js'];
+            if (hasServer)
+                files.push('server.js');
+            console.log(`[sh3-artifact] ${manifest.id}@${manifest.version} (${manifest.type}) → ${outDir}`);
+            console.log(`[sh3-artifact] files: ${files.join(', ')}`);
+        },
+    };
+}

package/dist/contract.d.ts

@@ -0,0 +1,20 @@
+export declare const contract: {
+    readonly version: 1;
+    /** Import specifiers any shard/app source file may use. */
+    readonly shardImports: readonly ["sh3-core", "sh3-core/tokens.css"];
+    /** Import specifiers restricted to the host entry point only. */
+    readonly hostImports: readonly ["sh3-core/host"];
+    /** Contract-level prefix. Any import starting with 'sh3-core' that is not
+     *  listed in shardImports or hostImports is illegal. */
+    readonly packagePrefix: "sh3-core";
+    readonly shard: {
+        readonly requiredFields: readonly ["id", "label", "version", "views"];
+        readonly views: {
+            readonly requiredFields: readonly ["id", "label"];
+        };
+    };
+    readonly app: {
+        readonly requiredFields: readonly ["id", "label", "version", "requiredShards", "layoutVersion"];
+    };
+};
+export type Contract = typeof contract;

package/dist/contract.js

@@ -0,0 +1,28 @@
+/*
+ * Machine-readable contract descriptor.
+ *
+ * Imported as `import { contract } from 'sh3-core/contract'`. The validator
+ * package reads this to know what import paths are legal, what fields
+ * manifests must have, and which contract version is in play.
+ *
+ * Pure data — no runtime logic, no dependencies.
+ */
+export const contract = {
+    version: 1,
+    /** Import specifiers any shard/app source file may use. */
+    shardImports: ['sh3-core', 'sh3-core/tokens.css'],
+    /** Import specifiers restricted to the host entry point only. */
+    hostImports: ['sh3-core/host'],
+    /** Contract-level prefix. Any import starting with 'sh3-core' that is not
+     *  listed in shardImports or hostImports is illegal. */
+    packagePrefix: 'sh3-core',
+    shard: {
+        requiredFields: ['id', 'label', 'version', 'views'],
+        views: {
+            requiredFields: ['id', 'label'],
+        },
+    },
+    app: {
+        requiredFields: ['id', 'label', 'version', 'requiredShards', 'layoutVersion'],
+    },
+};

package/dist/createShell.d.ts

@@ -0,0 +1,24 @@
+import type { Shard, App } from './index';
+export interface ShellConfig {
+    /** Framework shard IDs to exclude (all included by default) */
+    excludeShards?: string[];
+    /** Additional shards to register */
+    shards?: Shard[];
+    /** Additional apps to register */
+    apps?: App[];
+    /**
+     * Packages discovered by the server at boot.
+     * The frontend fetches this list from /api/packages and passes it here.
+     */
+    discoveredPackages?: Array<{
+        id: string;
+        type: string;
+        version: string;
+        bundleUrl: string;
+    }>;
+    /** Mount target — CSS selector or element (defaults to '#app') */
+    target?: string | HTMLElement;
+    /** Server base URL ('' for same-origin) */
+    serverUrl?: string;
+}
+export declare function createShell(config?: ShellConfig): Promise<void>;

package/dist/createShell.js

@@ -0,0 +1,131 @@
+/*
+ * createShell — public factory for booting an SH3 shell.
+ *
+ * Consumers call this from their own main.ts instead of manually
+ * importing registerShard / registerApp / bootstrap / Shell. The
+ * factory handles platform detection, boot config, auth gating,
+ * registration, bootstrap, and mounting in the correct order.
+ */
+import { mount, unmount } from 'svelte';
+import { Shell } from './index';
+import { registerShard, registerApp, bootstrap, __setBackend, setLocalOwner, } from './host';
+import { resolvePlatform } from './platform/index';
+import { hydrateTokenOverrides } from './theme';
+import { __setEnvServerUrl } from './env/index';
+import { __setTenantId } from './documents/config';
+import { initFromBoot } from './auth/index';
+import SignInWall from './auth/SignInWall.svelte';
+export async function createShell(config) {
+    var _a, _b, _c;
+    const sUrl = (_a = config === null || config === void 0 ? void 0 : config.serverUrl) !== null && _a !== void 0 ? _a : '';
+    // 1. Platform detection
+    const platform = await resolvePlatform();
+    if (platform.backends) {
+        __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 shell)
+    const target = typeof (config === null || config === void 0 ? void 0 : config.target) === 'string'
+        ? document.querySelector(config.target)
+        : (_b = config === null || config === void 0 ? void 0 : config.target) !== null && _b !== void 0 ? _b : document.getElementById('app');
+    if (!target) {
+        throw new Error('SH3: mount target not found');
+    }
+    // 3. Fetch boot config (skip for local-owner platforms like Tauri/dev)
+    let bootConfig = null;
+    if (!platform.localOwner) {
+        try {
+            const res = await fetch(`${sUrl}/api/boot`, { credentials: 'include' });
+            if (res.ok) {
+                bootConfig = await res.json();
+            }
+        }
+        catch (_d) {
+            // Server unreachable — boot without auth (offline mode)
+        }
+    }
+    // 4. Auth decision point
+    if (platform.localOwner) {
+        // Local-owner (Tauri/dev): no auth, no sign-in, tenant is 'local'.
+        // setLocalOwner() already called above — admin is assumed.
+        __setTenantId('local');
+    }
+    else if (bootConfig) {
+        initFromBoot(sUrl, bootConfig);
+        __setTenantId(bootConfig.tenantId);
+        const { auth, session } = bootConfig;
+        // Hard gate: no session, auth required, no guest allowed → sign-in wall
+        if (!session && auth.required && !auth.guestAllowed) {
+            await showSignInWall(target, bootConfig);
+            // After successful sign-in, re-fetch boot config
+            const res = await fetch(`${sUrl}/api/boot`, { credentials: 'include' });
+            if (res.ok) {
+                bootConfig = await res.json();
+                initFromBoot(sUrl, bootConfig);
+                __setTenantId(bootConfig.tenantId);
+            }
+        }
+    }
+    // 5. Load server-discovered packages
+    if ((_c = config === null || config === void 0 ? void 0 : config.discoveredPackages) === null || _c === void 0 ? void 0 : _c.length) {
+        const { loadBundleModule } = await import('./registry/loader');
+        for (const pkg of config.discoveredPackages) {
+            try {
+                const res = await fetch(pkg.bundleUrl);
+                if (!res.ok) {
+                    console.warn(`[sh3] Failed to fetch discovered package "${pkg.id}": HTTP ${res.status}`);
+                    continue;
+                }
+                const bytes = await res.arrayBuffer();
+                const loaded = await loadBundleModule(bytes);
+                for (const s of loaded.shards)
+                    registerShard(s);
+                for (const a of loaded.apps)
+                    registerApp(a);
+                console.log(`[sh3] Loaded discovered package: ${pkg.id}`);
+            }
+            catch (err) {
+                console.warn(`[sh3] Failed to load discovered package "${pkg.id}":`, err);
+            }
+        }
+    }
+    // 6. Register consumer-provided shards and apps
+    if (config === null || config === void 0 ? void 0 : config.shards) {
+        for (const shard of config.shards)
+            registerShard(shard);
+    }
+    if (config === null || config === void 0 ? void 0 : config.apps) {
+        for (const app of config.apps)
+            registerApp(app);
+    }
+    // 7. Bootstrap
+    const bootstrapConfig = {};
+    if (config === null || config === void 0 ? void 0 : config.excludeShards)
+        bootstrapConfig.excludeShards = config.excludeShards;
+    await bootstrap(bootstrapConfig);
+    // 8. Mount the shell
+    mount(Shell, { target });
+}
+/**
+ * Show the sign-in wall and wait until the user authenticates.
+ * Returns a promise that resolves after successful login.
+ */
+function showSignInWall(target, bootConfig) {
+    return new Promise((resolve) => {
+        const instance = mount(SignInWall, {
+            target,
+            props: {
+                selfRegistration: bootConfig.auth.selfRegistration,
+                onSuccess: () => {
+                    unmount(instance);
+                    resolve();
+                },
+            },
+        });
+    });
+}

package/dist/documents/backends.d.ts

@@ -0,0 +1,17 @@
+import type { DocumentBackend, DocumentMeta } from './types';
+export declare class MemoryDocumentBackend implements DocumentBackend {
+    #private;
+    read(tenantId: string, shardId: string, path: string): Promise<string | ArrayBuffer | null>;
+    write(tenantId: string, shardId: string, path: string, content: string | ArrayBuffer): Promise<void>;
+    delete(tenantId: string, shardId: string, path: string): Promise<void>;
+    list(tenantId: string, shardId: string): Promise<DocumentMeta[]>;
+    exists(tenantId: string, shardId: string, path: string): Promise<boolean>;
+}
+export declare class IndexedDBDocumentBackend implements DocumentBackend {
+    #private;
+    read(tenantId: string, shardId: string, path: string): Promise<string | ArrayBuffer | null>;
+    write(tenantId: string, shardId: string, path: string, content: string | ArrayBuffer): Promise<void>;
+    delete(tenantId: string, shardId: string, path: string): Promise<void>;
+    list(tenantId: string, shardId: string): Promise<DocumentMeta[]>;
+    exists(tenantId: string, shardId: string, path: string): Promise<boolean>;
+}

package/dist/documents/backends.js

@@ -0,0 +1,156 @@
+/*
+ * Document zone backends — concrete storage implementations.
+ *
+ * MemoryDocumentBackend: Map-based, for tests and ephemeral use.
+ * IndexedDBDocumentBackend: The web default. Lazy-inits on first
+ *   operation to avoid blocking bootstrap.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function compositeKey(tenantId, shardId, path) {
+    return `${tenantId}/${shardId}/${path}`;
+}
+function keyPrefix(tenantId, shardId) {
+    return `${tenantId}/${shardId}/`;
+}
+export class MemoryDocumentBackend {
+    constructor() {
+        _MemoryDocumentBackend_store.set(this, new Map());
+    }
+    async read(tenantId, shardId, path) {
+        const entry = __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").get(compositeKey(tenantId, shardId, path));
+        return entry ? entry.content : null;
+    }
+    async write(tenantId, shardId, path, content) {
+        const size = typeof content === 'string' ? new Blob([content]).size : content.byteLength;
+        __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").set(compositeKey(tenantId, shardId, path), {
+            content,
+            size,
+            lastModified: Date.now(),
+        });
+    }
+    async delete(tenantId, shardId, path) {
+        __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").delete(compositeKey(tenantId, shardId, path));
+    }
+    async list(tenantId, shardId) {
+        const prefix = keyPrefix(tenantId, shardId);
+        const out = [];
+        for (const [key, entry] of __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f")) {
+            if (key.startsWith(prefix)) {
+                out.push({
+                    path: key.slice(prefix.length),
+                    size: entry.size,
+                    lastModified: entry.lastModified,
+                });
+            }
+        }
+        return out;
+    }
+    async exists(tenantId, shardId, path) {
+        return __classPrivateFieldGet(this, _MemoryDocumentBackend_store, "f").has(compositeKey(tenantId, shardId, path));
+    }
+}
+_MemoryDocumentBackend_store = new WeakMap();
+// ---------------------------------------------------------------------------
+// IndexedDBDocumentBackend
+// ---------------------------------------------------------------------------
+const IDB_NAME = 'sh3-documents';
+const IDB_STORE = 'docs';
+const IDB_VERSION = 2;
+export class IndexedDBDocumentBackend {
+    constructor() {
+        _IndexedDBDocumentBackend_instances.add(this);
+        _IndexedDBDocumentBackend_dbPromise.set(this, null);
+    }
+    async read(tenantId, shardId, path) {
+        const key = compositeKey(tenantId, shardId, path);
+        const entry = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readonly', (s) => s.get(key));
+        return entry ? entry.content : null;
+    }
+    async write(tenantId, shardId, path, content) {
+        const key = compositeKey(tenantId, shardId, path);
+        const size = typeof content === 'string' ? new Blob([content]).size : content.byteLength;
+        const entry = { content, size, lastModified: Date.now() };
+        await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readwrite', (s) => s.put(entry, key));
+    }
+    async delete(tenantId, shardId, path) {
+        const key = compositeKey(tenantId, shardId, path);
+        await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readwrite', (s) => s.delete(key));
+    }
+    async list(tenantId, shardId) {
+        const prefix = keyPrefix(tenantId, shardId);
+        const db = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this);
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(IDB_STORE, 'readonly');
+            const store = tx.objectStore(IDB_STORE);
+            // IDBKeyRange.bound selects all keys that start with the prefix.
+            // The upper bound appends a character beyond '/' to capture all
+            // sub-paths without over-selecting.
+            const range = IDBKeyRange.bound(prefix, prefix + '\uffff', false, false);
+            const req = store.openCursor(range);
+            const out = [];
+            req.onsuccess = () => {
+                const cursor = req.result;
+                if (cursor) {
+                    const entry = cursor.value;
+                    out.push({
+                        path: cursor.key.slice(prefix.length),
+                        size: entry.size,
+                        lastModified: entry.lastModified,
+                    });
+                    cursor.continue();
+                }
+                else {
+                    resolve(out);
+                }
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async exists(tenantId, shardId, path) {
+        const key = compositeKey(tenantId, shardId, path);
+        // getKey is cheaper than get — avoids deserializing the value.
+        const result = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_tx).call(this, 'readonly', (s) => s.getKey(key));
+        return result !== undefined;
+    }
+}
+_IndexedDBDocumentBackend_dbPromise = new WeakMap(), _IndexedDBDocumentBackend_instances = new WeakSet(), _IndexedDBDocumentBackend_db = function _IndexedDBDocumentBackend_db() {
+    if (!__classPrivateFieldGet(this, _IndexedDBDocumentBackend_dbPromise, "f")) {
+        __classPrivateFieldSet(this, _IndexedDBDocumentBackend_dbPromise, new Promise((resolve, reject) => {
+            const req = indexedDB.open(IDB_NAME, IDB_VERSION);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                if (!db.objectStoreNames.contains(IDB_STORE)) {
+                    db.createObjectStore(IDB_STORE);
+                }
+            };
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        }), "f");
+    }
+    return __classPrivateFieldGet(this, _IndexedDBDocumentBackend_dbPromise, "f");
+}, _IndexedDBDocumentBackend_tx = 
+/** Run a single-store transaction and return the request result. */
+async function _IndexedDBDocumentBackend_tx(mode, fn) {
+    const db = await __classPrivateFieldGet(this, _IndexedDBDocumentBackend_instances, "m", _IndexedDBDocumentBackend_db).call(this);
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction(IDB_STORE, mode);
+        const store = tx.objectStore(IDB_STORE);
+        const req = fn(store);
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+};

package/dist/documents/config.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentBackend } from './types';
+export declare function getTenantId(): string;
+export declare function getDocumentBackend(): DocumentBackend;
+/** Host-only. Set the tenant id before bootstrap(). */
+export declare function __setTenantId(id: string): void;
+/** Host-only. Swap the document backend before bootstrap(). */
+export declare function __setDocumentBackend(b: DocumentBackend): void;