opfs-worker 2.0.0 → 2.1.1

package/src/{OPFSFacade.ts → facade/OPFSFacade.ts}

@@ -1,5 +1,6 @@
-import { createOPFSWorker } from './createOPFSWorker';
-import { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';
+import { proxy, transfer } from 'comlink';
+
+import { decodeBuffer, encodeString, isBinaryFileExtension } from '../utils/encoder';
 
 import type {
     BinaryEncoding,
@@ -7,13 +8,16 @@ import type {
     Encoding,
     FileOpenOptions,
     FileStat,
+    ImportFileData,
+    ImportFilesProgress,
+    ImportFilesResult,
+    OPFSApi,
     OPFSOptions,
     PathLike,
-    RemoteOPFSWorker,
     RenameOptions,
     StringEncoding,
     WatchOptions
-} from './types';
+} from '../types';
 
 /**
  * Utility function to convert a PathLike to a string path
@@ -27,22 +31,48 @@ function normalizePath(path: PathLike): string {
     return path;
 }
 
+let createIndexWarned = false;
+
+function warnCreateIndexDeprecated(): void {
+    if (createIndexWarned) {
+        return;
+    }
+
+    createIndexWarned = true;
+    console.warn('[opfs-worker] createIndex() is deprecated; use importFiles() instead');
+}
+
+/** Backend the facade talks to: an fs implementation plus its cleanup. */
+export interface OPFSBackend {
+    fs: OPFSApi;
+    /** Underlying Worker / SharedWorker when the backend lives off-thread */
+    worker?: Worker | SharedWorker;
+    dispose: () => void;
+}
+
 /**
- * Mode 1: Node-like facade with encoding helpers and string/binary auto-detection,
- * built on top of the raw worker API from {@link createOPFSWorker}.
+ * Node-like facade with encoding helpers and string/binary auto-detection.
  *
- * Use {@link createOPFS} to create one.
+ * Transport-agnostic: works over any {@link OPFSBackend} — a Comlink proxy to
+ * a worker (`createOPFSDedicated`) or an in-process instance (`createOPFSAsync`).
+ *
+ * Escape hatch: {@link backend} is the raw bytes API; {@link worker} is the
+ * browser Worker / SharedWorker when one was created (undefined for async).
  */
 export class OPFSFacade {
-    #fs: RemoteOPFSWorker;
+    #fs: OPFSApi;
     #dispose: () => void;
+    /** Raw backend (`OPFSApi`) — bytes in / bytes out, no encoding helpers */
+    readonly backend: OPFSApi;
+    /** Dedicated Worker or SharedWorker, if this facade was created with one */
+    readonly worker: Worker | SharedWorker | undefined;
     promises: OPFSFacade = this;
 
-    constructor(options?: OPFSOptions) {
-        const raw = createOPFSWorker(options);
-
-        this.#fs = raw.fs;
-        this.#dispose = raw.dispose;
+    constructor(backend: OPFSBackend) {
+        this.#fs = backend.fs;
+        this.backend = backend.fs;
+        this.worker = backend.worker;
+        this.#dispose = backend.dispose;
     }
 
     /**
@@ -120,12 +150,40 @@ export class OPFSFacade {
         return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);
     }
 
+    /**
+     * Normalize writable data into a Uint8Array.
+     *
+     * Accepts strings (encoded via `encoding`, auto-detected from the file
+     * extension when omitted), raw binary (`Uint8Array` / `ArrayBuffer`), and
+     * `Blob`/`File` sources (read via `arrayBuffer()`).
+     */
+    async #toBuffer(
+        path: string,
+        data: string | Uint8Array | ArrayBuffer | Blob,
+        encoding?: Encoding
+    ): Promise<Uint8Array> {
+        if (data instanceof Blob) {
+            return new Uint8Array(await data.arrayBuffer());
+        }
+
+        // If no encoding specified, auto-detect based on file extension
+        if (!encoding) {
+            encoding = (typeof data !== 'string' || isBinaryFileExtension(path)) ? 'binary' : 'utf-8';
+        }
+
+        if (typeof data === 'string') {
+            return encodeString(data, encoding);
+        }
+
+        return data instanceof Uint8Array ? data : new Uint8Array(data);
+    }
+
     /**
      * Write data to a file
      */
     async writeFile(
         path: PathLike,
-        data: string | Uint8Array | ArrayBuffer,
+        data: string | Uint8Array | ArrayBuffer | Blob,
         options?: { encoding?: Encoding } | Encoding
     ): Promise<void> {
         const normalizedPath = normalizePath(path);
@@ -139,15 +197,7 @@ export class OPFSFacade {
             encoding = options.encoding;
         }
 
-        // If no encoding specified, auto-detect based on file extension
-        if (!encoding) {
-            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';
-        }
-
-        // Convert data to Uint8Array
-        const buffer = typeof data === 'string'
-            ? encodeString(data, encoding)
-            : (data instanceof Uint8Array ? data : new Uint8Array(data));
+        const buffer = await this.#toBuffer(normalizedPath, data, encoding);
 
         return this.#fs.writeFile(normalizedPath, buffer);
     }
@@ -157,24 +207,37 @@ export class OPFSFacade {
      */
     async appendFile(
         path: PathLike,
-        data: string | Uint8Array | ArrayBuffer,
+        data: string | Uint8Array | ArrayBuffer | Blob,
         encoding?: Encoding
     ): Promise<void> {
         const normalizedPath = normalizePath(path);
 
-        // If no encoding specified, auto-detect based on file extension
-        if (!encoding) {
-            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';
-        }
-
-        // Convert data to Uint8Array
-        const buffer = typeof data === 'string'
-            ? encodeString(data, encoding)
-            : (data instanceof Uint8Array ? data : new Uint8Array(data));
+        const buffer = await this.#toBuffer(normalizedPath, data, encoding);
 
         return this.#fs.appendFile(normalizedPath, buffer);
     }
 
+    /**
+     * Create or overwrite a file from a byte stream without buffering the
+     * complete source in memory.
+     *
+     * Returns the total number of bytes written.
+     */
+    async importStream(
+        path: PathLike,
+        source: ReadableStream<Uint8Array> | Blob,
+        options?: { onProgress?: (bytesWritten: number) => void }
+    ): Promise<number> {
+        const normalizedPath = normalizePath(path);
+        const stream = source instanceof Blob ? source.stream() : source;
+        const transferredStream = transfer(stream, [stream]) as unknown as ReadableStream<Uint8Array>;
+        const onProgress = options?.onProgress
+            ? proxy((bytesWritten: number) => options.onProgress!(bytesWritten))
+            : undefined;
+
+        return this.#fs.writeStream(normalizedPath, transferredStream, onProgress);
+    }
+
     /**
      * Create a directory
      */
@@ -393,12 +456,45 @@ export class OPFSFacade {
     }
 
     /**
-     * Synchronize the file system with external data
+     * Read a file as a lazy, disk-backed `Blob` without copying the data to memory.
+     *
+     * Ideal for `URL.createObjectURL()`: the browser streams `<video>` / `<audio>`
+     * on demand instead of loading the whole file first.
      */
-    async createIndex(entries: [PathLike, string | Uint8Array | Blob][]): Promise<void> {
-        const normalizedEntries = entries.map(([path, data]) => [normalizePath(path), data] as [string, string | Uint8Array | Blob]);
+    async readBlob(path: PathLike): Promise<Blob> {
+        return this.#fs.readBlob(normalizePath(path));
+    }
 
-        return this.#fs.createIndex(normalizedEntries);
+    /**
+     * Bulk-import files from `[path, data]` entries (strings, bytes, Blobs, or Files).
+     * Each entry is streamed via {@link importStream} / `writeStream` so large
+     * Blobs/Files are not fully buffered in memory.
+     *
+     * Accepts an array of tuples, a `Map`, or any iterable of `[path, data]` pairs.
+     * Returns written paths, count, and total bytes.
+     */
+    async importFiles(
+        entries: Iterable<[PathLike, ImportFileData]> | Map<string, ImportFileData>,
+        options?: { onProgress?: (progress: ImportFilesProgress) => void }
+    ): Promise<ImportFilesResult> {
+        const normalizedEntries = [...entries].map(([path, data]) => [
+            normalizePath(path),
+            data,
+        ] as [string, ImportFileData]);
+
+        const onProgress = options?.onProgress
+            ? proxy((progress: ImportFilesProgress) => options.onProgress!(progress))
+            : undefined;
+
+        return this.#fs.importFiles(normalizedEntries, onProgress);
+    }
+
+    /**
+     * @deprecated Use {@link importFiles} instead.
+     */
+    async createIndex(entries: Iterable<[PathLike, ImportFileData]> | Map<string, ImportFileData>): Promise<void> {
+        warnCreateIndexDeprecated();
+        await this.importFiles(entries);
     }
 
     /**
@@ -432,29 +528,9 @@ export class OPFSFacade {
     }
 
     /**
-     * Dispose of resources, detach the worker and clean up the file system instance
+     * Dispose of resources, detach the backend and clean up the file system instance
      */
     dispose() {
         this.#dispose();
     }
 }
-
-/**
- * Mode 1: start an inlined worker and get a Node-like `fs` API on top of it.
- *
- * For the raw worker API without the facade, use {@link createOPFSWorker}.
- * To use the worker class inside your own worker, see `opfs-worker/pure`.
- */
-export function createOPFS(options?: OPFSOptions): OPFSFacade {
-    return new OPFSFacade(options);
-}
-
-/**
- * @deprecated Use {@link createOPFS}. Kept for 1.x compatibility — still returns the facade.
- */
-export const createWorker = createOPFS;
-
-/**
- * @deprecated Use {@link OPFSFacade}.
- */
-export { OPFSFacade as OPFSFileSystem };

package/src/facade/createOPFSAsync.ts

@@ -0,0 +1,22 @@
+import { OPFSFacade } from './OPFSFacade';
+import { OPFSAsync } from '../core/OPFSAsync';
+
+import type { OPFSOptions } from '../types';
+
+/**
+ * Async mode: Node-like `fs` API over the promise-based File System API,
+ * without any worker.
+ *
+ * Prefer importing from `opfs-worker/async` when you care about bundle size
+ * (avoids the inlined dedicated worker). Importing from `opfs-worker` works too.
+ *
+ * Writing requires `FileSystemFileHandle.createWritable()` — Chrome, Firefox,
+ * Safari 26+. File descriptors (`open`/`read`/`write`/...) are not supported
+ * and throw `OperationNotSupportedError` — use `createOPFSDedicated` from `opfs-worker`
+ * or `opfs-worker/sync` for positional I/O.
+ */
+export function createOPFSAsync(options?: OPFSOptions): OPFSFacade {
+    const fs = new OPFSAsync(options);
+
+    return new OPFSFacade({ fs, dispose: () => fs.dispose() });
+}

package/src/facade/createOPFSDedicated.ts

@@ -0,0 +1,23 @@
+import { OPFSFacade } from './OPFSFacade';
+import { createDedicatedWorker } from '../worker/createDedicatedWorker';
+
+import type { DedicatedWorkerOptions } from '../worker/createDedicatedWorker';
+
+/**
+ * Dedicated mode: start a dedicated worker and get a Node-like `fs` API
+ * backed by `OPFSSync`.
+ *
+ * Prefer importing from `opfs-worker/sync` when you only need the worker backend
+ * (avoids pulling `OPFSAsync` into the graph). Importing from `opfs-worker` works too.
+ *
+ * By default uses an inlined worker. Pass `url` / `worker` to load
+ * `opfs-worker/dedicated.worker.js` instead (see {@link DedicatedWorkerOptions}).
+ *
+ * Need the raw bytes API or the Worker instance? Use `fs.backend` / `fs.worker`.
+ * For the workerless async backend, use {@link createOPFSAsync}.
+ */
+export function createOPFSDedicated(options?: DedicatedWorkerOptions): OPFSFacade {
+    const { fs, worker, dispose } = createDedicatedWorker(options);
+
+    return new OPFSFacade({ fs, worker, dispose });
+}

package/src/facade/createOPFSShared.ts

@@ -0,0 +1,30 @@
+import { OPFSFacade } from './OPFSFacade';
+import { createSharedWorker } from '../worker/createSharedWorker';
+
+import type { SharedWorkerOptions } from '../worker/createSharedWorker';
+
+/**
+ * Shared mode: Node-like `fs` API over a SharedWorker running one `OPFSAsync`
+ * instance for every tab — writes are serialized across tabs by per-path locks,
+ * watch events reach all tabs via `BroadcastChannel`.
+ *
+ * Uses the async backend (sync access handles are unavailable in SharedWorker):
+ * writing requires `createWritable()` (Chrome, Firefox, Safari 26+), and file
+ * descriptors throw `OperationNotSupportedError`.
+ *
+ * Need the raw bytes API or the SharedWorker? Use `fs.backend` / `fs.worker`.
+ *
+ * @example
+ * ```typescript
+ * // Vite: pass the worker url explicitly
+ * import workerUrl from 'opfs-worker/shared.worker.js?url';
+ * import { createOPFSShared } from 'opfs-worker/sharedworker';
+ *
+ * const fs = createOPFSShared({ root: '/my-app', url: workerUrl });
+ * ```
+ */
+export function createOPFSShared(options?: SharedWorkerOptions): OPFSFacade {
+    const { fs, worker, dispose } = createSharedWorker(options);
+
+    return new OPFSFacade({ fs, worker, dispose });
+}

package/src/index.async.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export * from './utils/errors';
+export * from './utils/helpers';
+export * from './utils/encoder';
+
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSAsync } from './core/OPFSAsync';
+export { OPFSFacade } from './facade/OPFSFacade';
+export type { OPFSBackend } from './facade/OPFSFacade';
+
+export { createOPFSAsync } from './facade/createOPFSAsync';

package/src/index.pure.ts

@@ -3,5 +3,6 @@ export * from './utils/errors';
 export * from './utils/helpers';
 export * from './utils/encoder';
 
-// Explicit re-export shadows the type-only `OPFSWorker` coming from './types'
-export { OPFSWorker } from './OPFSWorker';
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSSync } from './core/OPFSSync';
+export { OPFSAsync } from './core/OPFSAsync';

package/src/index.sharedworker.ts

@@ -0,0 +1,12 @@
+export * from './types';
+export * from './utils/errors';
+export * from './utils/helpers';
+export * from './utils/encoder';
+
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSAsync } from './core/OPFSAsync';
+export { OPFSFacade } from './facade/OPFSFacade';
+export type { OPFSBackend } from './facade/OPFSFacade';
+
+export { createOPFSShared } from './facade/createOPFSShared';
+export type { SharedWorkerOptions } from './worker/createSharedWorker';

package/src/index.sync.ts

@@ -0,0 +1,12 @@
+export * from './types';
+export * from './utils/errors';
+export * from './utils/helpers';
+export * from './utils/encoder';
+
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSSync } from './core/OPFSSync';
+export { OPFSFacade } from './facade/OPFSFacade';
+export type { OPFSBackend } from './facade/OPFSFacade';
+
+export { createOPFSDedicated } from './facade/createOPFSDedicated';
+export type { DedicatedWorkerOptions } from './worker/createDedicatedWorker';

package/src/index.ts

@@ -4,12 +4,41 @@ export * from './utils/helpers';
 export * from './utils/encoder';
 
 export {
+    BaseOPFS,
     OPFSFacade,
-    OPFSFileSystem,
-    createOPFS,
-    // 1.x aliases
-    createWorker,
-} from './OPFSFacade';
-
-export { createOPFSWorker } from './createOPFSWorker';
-export type { RawWorker } from './createOPFSWorker';
+    OPFSSync,
+    createOPFSDedicated,
+} from './index.sync';
+
+export type {
+    DedicatedWorkerOptions,
+    OPFSBackend,
+} from './index.sync';
+
+export {
+    OPFSAsync,
+    createOPFSAsync,
+} from './index.async';
+
+export {
+    createOPFSShared,
+} from './index.sharedworker';
+
+export type {
+    SharedWorkerOptions,
+} from './index.sharedworker';
+
+/**
+ * Kept as a short alias for a default Sync backend
+ */
+export { createOPFSDedicated as createOPFS } from './index.sync';
+
+/**
+ * @deprecated Use {@link createOPFSDedicated}. Kept for 1.x → 2.x migration.
+ */
+export { createOPFSDedicated as createWorker } from './index.sync';
+
+/**
+ * @deprecated Use {@link OPFSFacade}. Kept for 1.x → 2.x migration.
+ */
+export { OPFSFacade as OPFSFileSystem } from './index.sync';

package/src/types.ts

@@ -1,5 +1,4 @@
-import type { OPFSWorker } from './OPFSWorker';
-import type { Remote } from 'comlink';
+import type { OPFSSync } from './core/OPFSSync';
 
 /**
  * Type for paths that can be either a string or URI
@@ -56,8 +55,13 @@ export interface WatchEvent {
     hash?: string;
 }
 
-export type { OPFSWorker };
-export type RemoteOPFSWorker = Remote<OPFSWorker>;
+export type { OPFSSync };
+
+/**
+ * Promise-based fs API surface shared by all backends: a Comlink proxy to
+ * `OPFSSync` in a worker, or an in-process `OPFSAsync` instance.
+ */
+export type OPFSApi = { [K in keyof OPFSSync]: OPFSSync[K] };
 
 export interface OPFSOptions {
     /** Root path for the file system (default: '/') */
@@ -72,6 +76,43 @@ export interface OPFSOptions {
     broadcastChannel?: string | BroadcastChannel | null;
 }
 
+/** Payload accepted by {@link importFiles} for a single entry. */
+export type ImportFileData = string | Uint8Array | Blob;
+
+/**
+ * Entries for {@link importFiles}: an array of `[path, data]` tuples, a `Map`,
+ * or any iterable that yields the same pairs.
+ */
+export type ImportFilesEntries = Iterable<[string, ImportFileData]> | Map<string, ImportFileData>;
+
+/** Progress event fired while {@link importFiles} writes entries. */
+export interface ImportFilesProgress {
+    /** Path of the file currently being written */
+    path: string;
+    /** 0-based index of the current file */
+    index: number;
+    /** Total number of entries in this import */
+    count: number;
+    /** Bytes written for the current file so far */
+    bytesWritten: number;
+    /** Size of the current file in bytes */
+    bytesTotal: number;
+    /** Bytes written across all files so far */
+    totalBytesWritten: number;
+    /** Sum of all entry sizes in bytes */
+    totalBytes: number;
+}
+
+/** Result of a finished {@link importFiles} call. */
+export interface ImportFilesResult {
+    /** Paths written, in import order */
+    paths: string[];
+    /** Number of files imported (`paths.length`) */
+    count: number;
+    /** Total bytes written across all files */
+    bytesWritten: number;
+}
+
 export interface RenameOptions {
     /** Whether to overwrite existing files (default: false) */
     overwrite?: boolean;

package/src/worker/createDedicatedWorker.ts

@@ -0,0 +1,74 @@
+import { wrap } from 'comlink';
+
+import WorkerCtor from './dedicated.worker?worker&inline';
+
+import type { OPFSOptions, OPFSSync } from '../types';
+import type { Remote } from 'comlink';
+
+const InlineWorker = WorkerCtor as new (options?: WorkerOptions) => Worker;
+
+type RemoteOPFSSync = Remote<OPFSSync>;
+
+export interface DedicatedWorkerOptions extends OPFSOptions {
+    /**
+     * URL of the worker script, e.g. `import url from 'opfs-worker/dedicated.worker.js?url'` (Vite).
+     *
+     * Defaults to the inlined worker (no URL needed). Pass an explicit url when you
+     * prefer the self-contained file (strict CSP without `blob:`, or DIY hosting).
+     */
+    url?: string | URL;
+    /** Bring your own Worker instance (overrides `url`) */
+    worker?: Worker;
+}
+
+export interface RawWorker {
+    /** Comlink proxy to `OPFSSync` (bytes in / bytes out) */
+    fs: RemoteOPFSSync;
+    /** Underlying browser Worker */
+    worker: Worker;
+    /** Calls worker `dispose()` then `terminate()` */
+    dispose: () => void;
+}
+
+/** A `BroadcastChannel` instance can't cross the wire — send its name instead. */
+function applyWorkerOptions(fs: Pick<RemoteOPFSSync, 'setOptions'>, options?: OPFSOptions): void {
+    if (!options) {
+        return;
+    }
+
+    if (options.broadcastChannel instanceof BroadcastChannel) {
+        options.broadcastChannel = options.broadcastChannel.name;
+    }
+
+    void fs.setOptions(options);
+}
+
+/**
+ * Internal helper: spawn a dedicated worker and wrap `OPFSSync` with Comlink.
+ * Prefer {@link createOPFSDedicated}; access the proxy / Worker via
+ * `facade.backend` / `facade.worker`.
+ */
+export function createDedicatedWorker(options: DedicatedWorkerOptions = {}): RawWorker {
+    const { url, worker: providedWorker, ...fsOptions } = options;
+
+    const worker = providedWorker
+      ?? (url ? new Worker(url, { type: 'module' }) : new InlineWorker());
+    const fs = wrap<RemoteOPFSSync>(worker);
+
+    applyWorkerOptions(fs, fsOptions);
+
+    return {
+        fs,
+        worker,
+        dispose() {
+            void (async() => {
+                try {
+                    await fs.dispose();
+                }
+                finally {
+                    worker.terminate();
+                }
+            })();
+        },
+    };
+}

package/src/worker/createSharedWorker.ts

@@ -0,0 +1,67 @@
+import { wrap } from 'comlink';
+
+import type { OPFSAsync } from '../core/OPFSAsync';
+import type { OPFSOptions } from '../types';
+import type { Remote } from 'comlink';
+
+type RemoteOPFSAsync = Remote<OPFSAsync>;
+
+export interface SharedWorkerOptions extends OPFSOptions {
+    /**
+     * URL of the worker script, e.g. `import url from 'opfs-worker/shared.worker.js?url'` (Vite).
+     *
+     * Defaults to `new URL('./shared.worker.js', import.meta.url)`, which works when
+     * `opfs-worker` is served as-is (CDN, unbundled deps). When your bundler inlines
+     * the package into app chunks, pass the url explicitly.
+     */
+    url?: string | URL;
+    /** Bring your own SharedWorker instance (overrides `url`) */
+    worker?: SharedWorker;
+    /** Worker name — tabs with the same script URL + name share one instance (default: 'opfs-worker') */
+    name?: string;
+}
+
+export interface RawSharedWorker {
+    /** Comlink proxy to the `OPFSAsync` instance shared by all connected tabs */
+    fs: RemoteOPFSAsync;
+    /** Underlying browser SharedWorker */
+    worker: SharedWorker;
+    /** Closes this tab's port; the worker keeps running for other tabs */
+    dispose: () => void;
+}
+
+/**
+ * Internal helper: connect to the SharedWorker and wrap `OPFSAsync` with Comlink.
+ * Prefer {@link createOPFSShared}; access the proxy / SharedWorker via
+ * `facade.backend` / `facade.worker`.
+ *
+ * Note: `OPFSOptions` are applied via `setOptions()` on the shared instance, so
+ * they affect every connected tab — use the same options in all tabs.
+ */
+export function createSharedWorker(options: SharedWorkerOptions = {}): RawSharedWorker {
+    const { url, worker: providedWorker, name = 'opfs-worker', ...fsOptions } = options;
+
+    const worker = providedWorker ?? new SharedWorker(
+        url ?? new URL('./shared.worker.js', import.meta.url),
+        { type: 'module', name }
+    );
+
+    const fs = wrap<RemoteOPFSAsync>(worker.port);
+
+    if (Object.keys(fsOptions).length > 0) {
+        // A BroadcastChannel instance can't cross the wire — send its name instead
+        if (fsOptions.broadcastChannel instanceof BroadcastChannel) {
+            fsOptions.broadcastChannel = fsOptions.broadcastChannel.name;
+        }
+
+        void fs.setOptions(fsOptions);
+    }
+
+    return {
+        fs,
+        worker,
+        dispose() {
+            worker.port.close();
+        },
+    };
+}

package/src/worker/dedicated.worker.ts

@@ -0,0 +1,13 @@
+import { expose } from 'comlink';
+
+import { OPFSSync } from '../core/OPFSSync';
+
+/**
+ * Dedicated worker entry.
+ *
+ * Built two ways:
+ * - Inlined into `createOPFSDedicated` via `?worker&inline` (default path)
+ * - Self-contained `dist/dedicated.worker.js` → `opfs-worker/dedicated.worker.js`
+ *   for DIY `new Worker(url, { type: 'module' })` + Comlink wrap
+ */
+expose(new OPFSSync());