opfs-worker 0.1.1

package/dist/inline.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline.cjs","sources":["../src/inline.ts"],"sourcesContent":["/**\n * Inline worker export for factory-based worker creation\n * \n * This export provides a factory function that creates worker instances with Comlink wrapping.\n * Use this when you want a simple, ready-to-use file system interface.\n * \n * @example\n * ```typescript\n * import { createWorker } from 'opfs-worker/inline-worker';\n * \n * const fs = await createWorker();\n * await fs.writeFile('/test.txt', 'Hello World');\n * ```\n */\n\nimport { wrap, type Remote } from 'comlink';\n\nimport WorkerCtor from './opfs.worker?worker&inline';\n\nimport type { OPFSWorker } from './types';\n\nexport * from './types';\n\nexport type RemoteOPFSWorker = Remote<OPFSWorker>;\n\n/**\n * Creates a new file system instance with inline worker\n * @returns Promise resolving to the file system interface\n */\nexport async function createWorker(): Promise<RemoteOPFSWorker> {\n    return wrap<OPFSWorker>(new WorkerCtor());\n}\n"],"names":["createWorker","wrap","WorkerCtor"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdA6BA,eAAsBA,GAA0C,CAC5D,OAAOC,EAAAA,KAAiB,IAAIC,CAAY,CAC5C"}

package/dist/inline.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Inline worker export for factory-based worker creation
+ *
+ * This export provides a factory function that creates worker instances with Comlink wrapping.
+ * Use this when you want a simple, ready-to-use file system interface.
+ *
+ * @example
+ * ```typescript
+ * import { createWorker } from 'opfs-worker/inline-worker';
+ *
+ * const fs = await createWorker();
+ * await fs.writeFile('/test.txt', 'Hello World');
+ * ```
+ */
+import { type Remote } from 'comlink';
+import type { OPFSWorker } from './types';
+export * from './types';
+export type RemoteOPFSWorker = Remote<OPFSWorker>;
+/**
+ * Creates a new file system instance with inline worker
+ * @returns Promise resolving to the file system interface
+ */
+export declare function createWorker(): Promise<RemoteOPFSWorker>;
+//# sourceMappingURL=inline.d.ts.map

package/dist/inline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline.d.ts","sourceRoot":"","sources":["../src/inline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAI5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,cAAc,SAAS,CAAC;AAExB,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAElD;;;GAGG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAE9D"}

package/dist/inline.js

@@ -0,0 +1,24 @@
+/**
+ * Inline worker export for factory-based worker creation
+ *
+ * This export provides a factory function that creates worker instances with Comlink wrapping.
+ * Use this when you want a simple, ready-to-use file system interface.
+ *
+ * @example
+ * ```typescript
+ * import { createWorker } from 'opfs-worker/inline-worker';
+ *
+ * const fs = await createWorker();
+ * await fs.writeFile('/test.txt', 'Hello World');
+ * ```
+ */
+import { wrap } from 'comlink';
+import WorkerCtor from './opfs.worker?worker&inline';
+export * from './types';
+/**
+ * Creates a new file system instance with inline worker
+ * @returns Promise resolving to the file system interface
+ */
+export async function createWorker() {
+    return wrap(new WorkerCtor());
+}

package/dist/inline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline.js","sources":["../src/inline.ts"],"sourcesContent":["/**\n * Inline worker export for factory-based worker creation\n * \n * This export provides a factory function that creates worker instances with Comlink wrapping.\n * Use this when you want a simple, ready-to-use file system interface.\n * \n * @example\n * ```typescript\n * import { createWorker } from 'opfs-worker/inline-worker';\n * \n * const fs = await createWorker();\n * await fs.writeFile('/test.txt', 'Hello World');\n * ```\n */\n\nimport { wrap, type Remote } from 'comlink';\n\nimport WorkerCtor from './opfs.worker?worker&inline';\n\nimport type { OPFSWorker } from './types';\n\nexport * from './types';\n\nexport type RemoteOPFSWorker = Remote<OPFSWorker>;\n\n/**\n * Creates a new file system instance with inline worker\n * @returns Promise resolving to the file system interface\n */\nexport async function createWorker(): Promise<RemoteOPFSWorker> {\n    return wrap<OPFSWorker>(new WorkerCtor());\n}\n"],"names":["createWorker","wrap","WorkerCtor"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,eAAsBA,IAA0C;AAC5D,SAAOC,EAAiB,IAAIC,GAAY;AAC5C;"}

package/dist/opfs.worker.d.ts

@@ -0,0 +1,447 @@
+import type { DirentData, FileStat } from './types';
+import type { BufferEncoding } from 'typescript';
+/**
+ * OPFS (Origin Private File System) File System implementation
+ *
+ * This class provides a high-level interface for working with the browser's
+ * Origin Private File System API, offering file and directory operations
+ * similar to Node.js fs module.
+ *
+ * @example
+ * ```typescript
+ * const fs = new OPFSFileSystem();
+ * await fs.init('/my-app');
+ * await fs.writeFile('/data/config.json', JSON.stringify({ theme: 'dark' }));
+ * const config = await fs.readFile('/data/config.json');
+ * ```
+ */
+export declare class OPFSWorker {
+    /** Root directory handle for the file system */
+    private root;
+    /**
+     * Creates a new OPFSFileSystem instance
+     *
+     * @throws {OPFSError} If OPFS is not supported in the current browser
+     */
+    constructor();
+    /**
+     * Initialize the file system within a given directory
+     *
+     * This method sets up the root directory for all subsequent operations.
+     * It must be called before any other file system operations.
+     *
+     * @param root - The root path for the file system (default: '/')
+     * @returns Promise that resolves to true if initialization was successful
+     * @throws {OPFSError} If initialization fails
+     *
+     * @example
+     * ```typescript
+     * const fs = new OPFSFileSystem();
+     * const success = await fs.init('/my-app');
+     * ```
+     */
+    mount(root?: string): Promise<boolean>;
+    /**
+     * Get a directory handle from a path
+     *
+     * Navigates through the directory structure to find or create a directory
+     * at the specified path.
+     *
+     * @param path - The path to the directory (string or array of segments)
+     * @param create - Whether to create the directory if it doesn't exist (default: false)
+     * @param from - The directory to start from (default: root directory)
+     * @returns Promise that resolves to the directory handle
+     * @throws {OPFSError} If the directory cannot be accessed or created
+     *
+     * @example
+     * ```typescript
+     * const docsDir = await fs.getDirectoryHandle('/users/john/documents', true);
+     * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
+     * ```
+     */
+    private getDirectoryHandle;
+    /**
+     * Get a file handle from a path
+     *
+     * Navigates to the parent directory and retrieves or creates a file handle
+     * for the specified file path.
+     *
+     * @param path - The path to the file (string or array of segments)
+     * @param create - Whether to create the file if it doesn't exist (default: false)
+     * @param from - The directory to start from (default: root directory)
+     * @returns Promise that resolves to the file handle
+     * @throws {PathError} If the path is empty
+     * @throws {OPFSError} If the file cannot be accessed or created
+     *
+     * @example
+     * ```typescript
+     * const fileHandle = await fs.getFileHandle('/config/settings.json', true);
+     * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
+     * ```
+     */
+    private getFileHandle;
+    /**
+     * Recursively list all files and directories with their stats
+     *
+     * Traverses the entire file system starting from the root and returns
+     * a Map containing all paths and their corresponding file statistics.
+     *
+     * @param options - Options for indexing
+     * @param options.includeHash - Whether to calculate file hash (default: false)
+     * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
+     * @returns Promise that resolves to a Map of path => FileStat
+     * @throws {OPFSError} If the indexing operation fails
+     *
+     * @example
+     * ```typescript
+     * // Basic index without hash
+     * const index = await fs.index();
+     *
+     * // Index with file hash
+     * const indexWithHash = await fs.index({
+     *   includeHash: true,
+     *   hashAlgorithm: 'SHA-1'
+     * });
+     *
+     * // Iterate through all files and directories
+     * for (const [path, stat] of index) {
+     *   console.log(`${path}: ${stat.isFile ? 'file' : 'directory'} (${stat.size} bytes)`);
+     *   if (stat.hash) console.log(`  Hash: ${stat.hash}`);
+     * }
+     *
+     * // Get specific file stats
+     * const fileStats = index.get('/data/config.json');
+     * if (fileStats) {
+     *   console.log(`File size: ${fileStats.size} bytes`);
+     *   if (fileStats.hash) console.log(`Hash: ${fileStats.hash}`);
+     * }
+     * ```
+     */
+    index(options?: {
+        includeHash?: boolean;
+        hashAlgorithm?: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+    }): Promise<Map<string, FileStat>>;
+    /**
+     * Read a file from the file system
+     *
+     * Reads the contents of a file and returns it as a string or binary data
+     * depending on the specified encoding.
+     *
+     * @param path - The path to the file to read
+     * @param encoding - The encoding to use for reading the file
+     * @returns Promise that resolves to the file contents
+     * @throws {FileNotFoundError} If the file does not exist
+     * @throws {OPFSError} If reading the file fails
+     *
+     * @example
+     * ```typescript
+     * // Read as text
+     * const content = await fs.readFile('/config/settings.json');
+     *
+     * // Read as binary
+     * const binaryData = await fs.readFile('/images/logo.png', 'binary');
+     *
+     * // Read with specific encoding
+     * const utf8Content = await fs.readFile('/data/utf8.txt', 'utf-8');
+     * ```
+     */
+    readFile(path: string, encoding: 'binary'): Promise<Uint8Array>;
+    readFile(path: string, encoding?: BufferEncoding): Promise<string>;
+    /**
+     * Write data to a file
+     *
+     * Creates or overwrites a file with the specified data. If the file already
+     * exists, it will be truncated before writing.
+     *
+     * @param path - The path to the file to write
+     * @param data - The data to write to the file (string, Uint8Array, or ArrayBuffer)
+     * @param encoding - The encoding to use when writing string data (default: 'utf-8')
+     * @returns Promise that resolves when the write operation is complete
+     * @throws {OPFSError} If writing the file fails
+     *
+     * @example
+     * ```typescript
+     * // Write text data
+     * await fs.writeFile('/config/settings.json', JSON.stringify({ theme: 'dark' }));
+     *
+     * // Write binary data
+     * const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
+     * await fs.writeFile('/data/binary.dat', binaryData);
+     *
+     * // Write with specific encoding
+     * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');
+     * ```
+     */
+    writeFile(path: string, data: string | Uint8Array | ArrayBuffer, encoding?: BufferEncoding): Promise<void>;
+    /**
+     * Append data to a file
+     *
+     * Adds data to the end of an existing file. If the file doesn't exist,
+     * it will be created.
+     *
+     * @param path - The path to the file to append to
+     * @param data - The data to append to the file (string, Uint8Array, or ArrayBuffer)
+     * @param encoding - The encoding to use when appending string data (default: 'utf-8')
+     * @returns Promise that resolves when the append operation is complete
+     * @throws {OPFSError} If appending to the file fails
+     *
+     * @example
+     * ```typescript
+     * // Append text to a log file
+     * await fs.appendFile('/logs/app.log', `[${new Date().toISOString()}] User logged in\n`);
+     *
+     * // Append binary data
+     * const additionalData = new Uint8Array([6, 7, 8]);
+     * await fs.appendFile('/data/binary.dat', additionalData);
+     * ```
+     */
+    appendFile(path: string, data: string | Uint8Array | ArrayBuffer, encoding?: BufferEncoding): Promise<void>;
+    /**
+     * Create a directory
+     *
+     * Creates a new directory at the specified path. If the recursive option
+     * is enabled, parent directories will be created as needed.
+     *
+     * @param path - The path where the directory should be created
+     * @param options - Options for directory creation
+     * @param options.recursive - Whether to create parent directories if they don't exist (default: false)
+     * @returns Promise that resolves when the directory is created
+     * @throws {OPFSError} If the directory cannot be created
+     *
+     * @example
+     * ```typescript
+     * // Create a single directory
+     * await fs.mkdir('/users/john');
+     *
+     * // Create nested directories
+     * await fs.mkdir('/users/john/documents/projects', { recursive: true });
+     * ```
+     */
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    /**
+     * Get file or directory stats
+     *
+     * Retrieves metadata about a file or directory, including size, modification time,
+     * type information, and optionally file hashes.
+     *
+     * @param path - The path to the file or directory
+     * @param options - Options for stat operation
+     * @param options.includeHash - Whether to calculate file hash (default: false, only for files)
+     * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
+     * @returns Promise that resolves to file/directory statistics
+     * @throws {OPFSError} If the file or directory does not exist or cannot be accessed
+     *
+     * @example
+     * ```typescript
+     * // Basic stats
+     * const stats = await fs.stat('/config/settings.json');
+     * console.log(`File size: ${stats.size} bytes`);
+     * console.log(`Is file: ${stats.isFile}`);
+     * console.log(`Modified: ${stats.mtime}`);
+     *
+     * // Stats with hash (SHA-1 is fastest)
+     * const statsWithHash = await fs.stat('/config/settings.json', {
+     *   includeHash: true,
+     *   hashAlgorithm: 'SHA-1'
+     * });
+     * console.log(`Hash: ${statsWithHash.hash}`);
+     * ```
+     */
+    stat(path: string, options?: {
+        includeHash?: boolean;
+        hashAlgorithm?: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+    }): Promise<FileStat>;
+    /**
+     * Read a directory's contents
+     *
+     * Lists all files and subdirectories within the specified directory.
+     *
+     * @param path - The path to the directory to read
+     * @param options - Options for the readdir operation
+     * @param options.withFileTypes - Whether to return detailed file information (default: false)
+     * @returns Promise that resolves to an array of file/directory names or detailed information
+     * @throws {OPFSError} If the directory does not exist or cannot be accessed
+     *
+     * @example
+     * ```typescript
+     * // Get simple list of names
+     * const files = await fs.readdir('/users/john/documents');
+     * console.log('Files:', files); // ['readme.txt', 'config.json', 'images']
+     *
+     * // Get detailed information
+     * const detailed = await fs.readdir('/users/john/documents', { withFileTypes: true });
+     * detailed.forEach(item => {
+     *   console.log(`${item.name} - ${item.isFile ? 'file' : 'directory'}`);
+     * });
+     * ```
+     */
+    readdir(path: string): Promise<string[]>;
+    readdir(path: string, options: {
+        withFileTypes: true;
+    }): Promise<DirentData[]>;
+    readdir(path: string, options: {
+        withFileTypes: false;
+    }): Promise<string[]>;
+    /**
+     * Check if a file or directory exists
+     *
+     * Verifies if a file or directory exists at the specified path.
+     *
+     * @param path - The path to check
+     * @returns Promise that resolves to true if the file or directory exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const exists = await fs.exists('/config/settings.json');
+     * console.log(`File exists: ${exists}`);
+     * ```
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Clear all contents of a directory without removing the directory itself
+     *
+     * Removes all files and subdirectories within the specified directory,
+     * but keeps the directory itself.
+     *
+     * @param path - The path to the directory to clear (default: '/')
+     * @returns Promise that resolves when all contents are removed
+     * @throws {OPFSError} If the operation fails
+     *
+     * @example
+     * ```typescript
+     * // Clear root directory contents
+     * await fs.clear('/');
+     *
+     * // Clear specific directory contents
+     * await fs.clear('/data');
+     * ```
+     */
+    clear(path?: string): Promise<void>;
+    /**
+     * Remove files and directories
+     *
+     * Removes files and directories. Similar to Node.js fs.rm().
+     *
+     * @param path - The path to remove
+     * @param options - Options for removal
+     * @param options.recursive - Whether to remove directories and their contents recursively (default: false)
+     * @param options.force - Whether to ignore errors if the path doesn't exist (default: false)
+     * @returns Promise that resolves when the removal is complete
+     * @throws {OPFSError} If the removal fails
+     *
+     * @example
+     * ```typescript
+     * // Remove a file
+     * await fs.rm('/path/to/file.txt');
+     *
+     * // Remove a directory and all its contents
+     * await fs.rm('/path/to/directory', { recursive: true });
+     *
+     * // Remove with force (ignore if doesn't exist)
+     * await fs.rm('/maybe/exists', { force: true });
+     * ```
+     */
+    remove(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Resolve a path to an absolute path
+     *
+     * Resolves relative paths and normalizes path segments (like '..' and '.').
+     * Similar to Node.js fs.realpath() but without symlink resolution since OPFS doesn't support symlinks.
+     *
+     * @param path - The path to resolve
+     * @returns Promise that resolves to the absolute normalized path
+     * @throws {FileNotFoundError} If the path does not exist
+     * @throws {OPFSError} If path resolution fails
+     *
+     * @example
+     * ```typescript
+     * // Resolve relative path
+     * const absolute = await fs.realpath('./config/../data/file.txt');
+     * console.log(absolute); // '/data/file.txt'
+     * ```
+     */
+    realpath(path: string): Promise<string>;
+    /**
+     * Rename a file or directory
+     *
+     * Changes the name of a file or directory. If the target path already exists,
+     * it will be replaced.
+     *
+     * @param oldPath - The current path of the file or directory
+     * @param newPath - The new path for the file or directory
+     * @returns Promise that resolves when the rename operation is complete
+     * @throws {OPFSError} If the rename operation fails
+     *
+     * @example
+     * ```typescript
+     * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
+     * ```
+     */
+    rename(oldPath: string, newPath: string): Promise<void>;
+    /**
+     * Copy files and directories
+     *
+     * Copies files and directories. Similar to Node.js fs.cp().
+     *
+     * @param source - The source path to copy from
+     * @param destination - The destination path to copy to
+     * @param options - Options for copying
+     * @param options.recursive - Whether to copy directories recursively (default: false)
+     * @param options.force - Whether to overwrite existing files (default: true)
+     * @returns Promise that resolves when the copy operation is complete
+     * @throws {OPFSError} If the copy operation fails
+     *
+     * @example
+     * ```typescript
+     * // Copy a file
+     * await fs.cp('/source/file.txt', '/dest/file.txt');
+     *
+     * // Copy a directory and all its contents
+     * await fs.cp('/source/dir', '/dest/dir', { recursive: true });
+     *
+     * // Copy without overwriting existing files
+     * await fs.cp('/source', '/dest', { recursive: true, force: false });
+     * ```
+     */
+    copy(source: string, destination: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Synchronize the file system with external data
+     *
+     * Syncs the file system with an array of entries containing paths and data.
+     * This is useful for importing data from external sources or syncing with remote data.
+     *
+     * @param entries - Array of [path, data] tuples to sync
+     * @param options - Options for synchronization
+     * @param options.cleanBefore - Whether to clear the file system before syncing (default: false)
+     * @returns Promise that resolves when synchronization is complete
+     * @throws {OPFSError} If the synchronization fails
+     *
+     * @example
+     * ```typescript
+     * // Sync with external data
+     * const entries: [string, string | Uint8Array | Blob][] = [
+     *   ['/config.json', JSON.stringify({ theme: 'dark' })],
+     *   ['/data/binary.dat', new Uint8Array([1, 2, 3, 4])],
+     *   ['/upload.txt', new Blob(['file content'], { type: 'text/plain' })]
+     * ];
+     *
+     * // Sync without clearing existing files
+     * await fs.sync(entries);
+     *
+     * // Clean file system and then sync
+     * await fs.sync(entries, { cleanBefore: true });
+     * ```
+     */
+    sync(entries: [string, string | Uint8Array | Blob][], options?: {
+        cleanBefore?: boolean;
+    }): Promise<void>;
+}
+//# sourceMappingURL=opfs.worker.d.ts.map

package/dist/opfs.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opfs.worker.d.ts","sourceRoot":"","sources":["../src/opfs.worker.ts"],"names":[],"mappings":"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"}