vfs-kit 1.0.1 → 1.0.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 bengru07
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 bengru07
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,35 +1,145 @@
-# vfs-kit
-A headless-first Virtual File System for React. Complete with drag-and-drop hierarchy, tab management and pluggable storage adapters.
-
-## Building the library
-
-```bash
-npm install
-npm run build
-```
-
-The package is authored in TypeScript and exports ESM modules with declaration files. React, Tailwind, and any Shadcn UI components are declared as
-peer dependencies – a consuming project must provide them.
-
-## Using locally
-
-While developing you can link the package into a demo app:
-
-```bash
-cd ./*/vfs-kit-test
-npm link vfs-kit
-```
-
-Import components in your app:
-
-```tsx
-import { TreeView, useVfs } from "vfs-kit";
-```
-
-## Notes
-
-The current release only includes a simple placeholder component. Real
-Shadcn imports can be added once you’re ready; you may need to supply a
-local `declare module '@shadcn/ui';` or update tsconfig `moduleResolution` to
-`nodenext`.
-
+# vfs-kit Explorer — React + TypeScript + Vite
+
+A dual-pane file explorer built on top of `vfs-kit`, demonstrating a fully custom UI layer over a virtual filesystem engine. Features tabbed editing, drag-and-drop file tree, and per-file snapshot history.
+
+---
+
+## Features
+
+- **Dual-pane layout** — two independent `FilePane` instances (`Source` / `Target`), each with its own workspace, file tree, and tab strip
+- **Custom file tree** — built with `FileTree` + a fully custom `renderNode` prop; supports drag-and-drop reordering, inline rename (`InlineInput`), folder expand/collapse, and drop-zone overlays
+- **Tabbed editor** — uses `TabListBase` (not `TabList`) so tabs share a single `useVfsTabs` instance with the rest of the pane; tabs support dirty indicators, lock/unlock, drag-to-reorder, and close
+- **Per-file snapshot history** — `useFileHistory` hook manages snapshots per open file using only the public `fs` / `tree` surfaces from `useVfsEngine`; the `HistoryPanel` sidebar lets you label, take, restore, and remove snapshots
+- **Clean tab switching** — `Editor` is keyed on `node.id` so React fully remounts it on tab change, resetting both content state and history without any manual sync
+
+---
+
+## Architecture
+
+### `FilePane`
+
+The top-level pane component. Owns the single `useVfsTabs` instance for its workspace and passes it directly into `TabListBase` — this is important because `TabList` (the higher-level component) would create its own internal `useVfsTabs` instance, resulting in two disconnected reducer states.
+
+```
+FilePane
+├── FileTree (sidebar)          ← custom renderNode wired to tabs.open on file click
+├── TabListBase (tab strip)     ← driven by the same tabs instance as FileTree
+└── FileRenderer (editor area)
+    └── Editor (keyed on node.id)
+        ├── textarea
+        ├── useFileHistory
+        └── HistoryPanel
+```
+
+### `useFileHistory`
+
+Per-tab in-memory snapshot manager. Scoped to the currently open file — history is intentionally discarded when the tab closes.
+
+```ts
+const { snapshots, takeSnapshot, restore, remove, loading } = useFileHistory({
+    workspaceId: 'ws-a',
+    nodeId:      'some-file-id',
+    onRestore:   (bytes) => setContent(new TextDecoder().decode(bytes)),
+});
+```
+
+- `takeSnapshot(label?)` — calls `fs.snapshot`, then re-fetches via `tree.getSnapshots` to update the list immediately
+- `restore(index)` — fetches snapshot content, writes it back via `fs.write`, then calls `onRestore` so the editor syncs its controlled state
+- `remove(index)` — local-state removal only; `deleteSnapshot` is not yet a formal `VfsCommand` (see [Roadmap](#roadmap))
+
+Uses only the public `fs` / `tree` surfaces — no direct `engine` access.
+
+### `Editor`
+
+Extracted from `FilePane` and keyed on `node.id`. Owns its own `content` state initialised from `initialContent`, and delegates history entirely to `useFileHistory`. The `setContentRef` pattern ensures `onRestore` never captures a stale setter across re-renders.
+
+### `HistoryPanel`
+
+Collapsible sidebar rendered inside `Editor`. Shows snapshots most-recent first with timestamp and byte size. Each entry has restore (↺) and delete (🗑) actions. The label input submits on Enter or the `+` button.
+
+---
+
+## Key Implementation Notes
+
+### Why `TabListBase` instead of `TabList`
+
+`TabList` calls `useVfsTabs` internally, producing a second isolated reducer. `TabListBase` accepts the tab state as props, so the single instance created in `FilePane` is the source of truth for both the tree's `tabs.open()` calls and the tab strip's render.
+
+### Why `Editor` is keyed on `node.id`
+
+Without a key, switching tabs leaves the previous file's content in state. Keying causes React to fully unmount and remount `Editor`, which resets `content`, `snapshots`, and `loading` cleanly — no `useEffect` sync required.
+
+### Why `tree` is omitted from `useEffect` deps in `useFileHistory`
+
+`useVfsEngine` builds `tree` via an immediately-invoked `useCallback` (`useCallback(...)()`) so a new object reference is produced on every render. Including it in deps would cause an infinite reload loop. `nodeId` is the correct and only trigger.
+
+---
+
+## Roadmap
+
+- **`deleteSnapshot` as a formal command** — add `{ op: 'deleteSnapshot', fileId, index }` to `VfsCommand` in `VfsEngine`, wire it through `runSnapshot`, expose it on `VfsFsApi` as `fs.deleteSnapshot(fileId, index)`, then replace the local-only removal in `useFileHistory.remove` with that call
+- **Autosave snapshots** — `VfsEngineConfig` already has `history.autosave` — hook up a `setInterval` in `useFileHistory` when `autosave.enabled` is true
+- **Snapshot diff view** — compare snapshot content against current file content before restoring
+
+---
+
+## Vite / ESLint setup
+
+This project was scaffolded from the official React + TypeScript + Vite template.
+
+### Available plugins
+
+- [`@vitejs/plugin-react`](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) — uses Babel (or oxc with rolldown-vite) for Fast Refresh
+- [`@vitejs/plugin-react-swc`](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) — uses SWC for Fast Refresh
+
+### React Compiler
+
+Not enabled by default due to dev/build performance impact. See the [React Compiler installation docs](https://react.dev/learn/react-compiler/installation) to add it.
+
+### Type-aware ESLint rules
+
+For production apps, enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      tseslint.configs.recommendedTypeChecked,
+      // or tseslint.configs.strictTypeChecked for stricter rules
+      tseslint.configs.stylisticTypeChecked,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+])
+```
+
+You can also add React-specific lint rules:
+
+```js
+import reactX   from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      reactX.configs['recommended-typescript'],
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+])
+```

package/dist/VfsAdapter-BWjniD9Y.d.mts

@@ -0,0 +1,57 @@
+import { e as VfsNode, b as VfsFileNode, d as VfsFolderNode, f as VfsNodeOrder, c as VfsFileSnapshot, g as VfsOperation } from './VfsNode-D10gxL5W.mjs';
+
+interface VfsChange {
+    op: VfsOperation;
+    nodeIds: string[];
+    timestamp: number;
+}
+interface VfsSearchOptions {
+    scope?: string | null;
+    kind?: "file" | "folder";
+    includeTrashed?: boolean;
+}
+interface VfsCreateFileParams {
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+}
+interface VfsCreateFolderParams {
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+}
+declare abstract class VfsAdapter<TMeta = Record<string, unknown>> {
+    abstract readonly supportsHistory: boolean;
+    abstract generateId(): string;
+    abstract getNodes(ids: string[]): Promise<VfsNode<TMeta>[]>;
+    abstract getNodeById(id: string): Promise<VfsNode<TMeta> | null>;
+    abstract getNodeByPath(path: string): Promise<VfsNode<TMeta> | null>;
+    abstract getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    abstract getTrashed(): Promise<VfsNode<TMeta>[]>;
+    abstract search(query: string, options?: VfsSearchOptions): Promise<VfsNode<TMeta>[]>;
+    abstract readFile(id: string): Promise<Uint8Array>;
+    abstract writeFile(id: string, content: Uint8Array): Promise<void>;
+    abstract createFile(params: VfsCreateFileParams): Promise<VfsFileNode<TMeta>>;
+    abstract createFolder(params: VfsCreateFolderParams): Promise<VfsFolderNode<TMeta>>;
+    abstract updateNode(id: string, updates: Partial<VfsNode<TMeta>>): Promise<VfsNode<TMeta>>;
+    abstract deleteNode(id: string, permanent?: boolean): Promise<void>;
+    abstract deleteNodes(ids: string[], permanent?: boolean): Promise<void>;
+    abstract restoreNode(id: string): Promise<VfsNode<TMeta>>;
+    abstract purgeNode(id: string): Promise<void>;
+    abstract moveNode(id: string, newParentId: string | null): Promise<VfsNode<TMeta>>;
+    abstract moveNodes(ids: string[], newParentId: string | null): Promise<VfsNode<TMeta>[]>;
+    abstract lockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract unlockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract getOrder(parentId: string | null): Promise<VfsNodeOrder | null>;
+    abstract setOrder(parentId: string | null, orderedIds: string[]): Promise<void>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    saveSnapshot(fileId: string, content: Uint8Array, label?: string): Promise<VfsFileSnapshot>;
+    restoreSnapshot(fileId: string, index: number): Promise<void>;
+    deleteSnapshot(fileId: string, index: number): Promise<void>;
+    abstract onChanged(callback: (change: VfsChange) => void): () => void;
+}
+
+export { VfsAdapter as V, type VfsChange as a, type VfsCreateFileParams as b, type VfsCreateFolderParams as c, type VfsSearchOptions as d };

package/dist/VfsAdapter-DOBt_TyL.d.ts

@@ -0,0 +1,57 @@
+import { e as VfsNode, b as VfsFileNode, d as VfsFolderNode, f as VfsNodeOrder, c as VfsFileSnapshot, g as VfsOperation } from './VfsNode-D10gxL5W.js';
+
+interface VfsChange {
+    op: VfsOperation;
+    nodeIds: string[];
+    timestamp: number;
+}
+interface VfsSearchOptions {
+    scope?: string | null;
+    kind?: "file" | "folder";
+    includeTrashed?: boolean;
+}
+interface VfsCreateFileParams {
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+}
+interface VfsCreateFolderParams {
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+}
+declare abstract class VfsAdapter<TMeta = Record<string, unknown>> {
+    abstract readonly supportsHistory: boolean;
+    abstract generateId(): string;
+    abstract getNodes(ids: string[]): Promise<VfsNode<TMeta>[]>;
+    abstract getNodeById(id: string): Promise<VfsNode<TMeta> | null>;
+    abstract getNodeByPath(path: string): Promise<VfsNode<TMeta> | null>;
+    abstract getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    abstract getTrashed(): Promise<VfsNode<TMeta>[]>;
+    abstract search(query: string, options?: VfsSearchOptions): Promise<VfsNode<TMeta>[]>;
+    abstract readFile(id: string): Promise<Uint8Array>;
+    abstract writeFile(id: string, content: Uint8Array): Promise<void>;
+    abstract createFile(params: VfsCreateFileParams): Promise<VfsFileNode<TMeta>>;
+    abstract createFolder(params: VfsCreateFolderParams): Promise<VfsFolderNode<TMeta>>;
+    abstract updateNode(id: string, updates: Partial<VfsNode<TMeta>>): Promise<VfsNode<TMeta>>;
+    abstract deleteNode(id: string, permanent?: boolean): Promise<void>;
+    abstract deleteNodes(ids: string[], permanent?: boolean): Promise<void>;
+    abstract restoreNode(id: string): Promise<VfsNode<TMeta>>;
+    abstract purgeNode(id: string): Promise<void>;
+    abstract moveNode(id: string, newParentId: string | null): Promise<VfsNode<TMeta>>;
+    abstract moveNodes(ids: string[], newParentId: string | null): Promise<VfsNode<TMeta>[]>;
+    abstract lockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract unlockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract getOrder(parentId: string | null): Promise<VfsNodeOrder | null>;
+    abstract setOrder(parentId: string | null, orderedIds: string[]): Promise<void>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    saveSnapshot(fileId: string, content: Uint8Array, label?: string): Promise<VfsFileSnapshot>;
+    restoreSnapshot(fileId: string, index: number): Promise<void>;
+    deleteSnapshot(fileId: string, index: number): Promise<void>;
+    abstract onChanged(callback: (change: VfsChange) => void): () => void;
+}
+
+export { VfsAdapter as V, type VfsChange as a, type VfsCreateFileParams as b, type VfsCreateFolderParams as c, type VfsSearchOptions as d };

package/dist/VfsEngine-B6nhgyjQ.d.mts

@@ -0,0 +1,152 @@
+import { V as VfsAdapter, a as VfsChange } from './VfsAdapter-BWjniD9Y.mjs';
+import { V as VfsEngineConfig, e as VfsNode, c as VfsFileSnapshot } from './VfsNode-D10gxL5W.mjs';
+
+type VfsCommand = {
+    op: "create";
+    kind: "file";
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "create";
+    kind: "folder";
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "rename";
+    id: string;
+    newName: string;
+} | {
+    op: "delete";
+    ids: string[];
+    permanent?: boolean;
+} | {
+    op: "restore";
+    ids: string[];
+} | {
+    op: "purge";
+    ids: string[];
+} | {
+    op: "move";
+    ids: string[];
+    newParentId: string | null;
+} | {
+    op: "write";
+    id: string;
+    content: Uint8Array;
+} | {
+    op: "lock";
+    ids: string[];
+} | {
+    op: "unlock";
+    ids: string[];
+} | {
+    op: "reorder";
+    parentId: string | null;
+    orderedIds: string[];
+} | {
+    op: "snapshot";
+    fileId: string;
+    label?: string;
+};
+type VfsEventMap<TMeta> = {
+    created: VfsNode<TMeta>;
+    renamed: VfsNode<TMeta>;
+    deleted: {
+        ids: string[];
+        permanent: boolean;
+    };
+    restored: VfsNode<TMeta>[];
+    purged: {
+        ids: string[];
+    };
+    moved: VfsNode<TMeta>[];
+    written: {
+        id: string;
+    };
+    locked: VfsNode<TMeta>[];
+    unlocked: VfsNode<TMeta>[];
+    reordered: {
+        parentId: string | null;
+        orderedIds: string[];
+    };
+    warning: {
+        code: string;
+        tabId?: string;
+        nodeId?: string;
+    };
+    snapshot: VfsFileSnapshot;
+    pending: {
+        command: VfsCommand;
+    };
+    settled: {
+        command: VfsCommand;
+        success: boolean;
+    };
+    error: {
+        command: VfsCommand;
+        error: Error;
+    };
+    change: VfsChange;
+};
+type VfsEventListener<TMeta, K extends keyof VfsEventMap<TMeta>> = (payload: VfsEventMap<TMeta>[K]) => void;
+type CacheStrategy = "eager" | "lazy" | "hybrid";
+declare class VfsEngine<TMeta extends Record<string, unknown> | undefined = Record<string, unknown>> {
+    private adapter;
+    private config;
+    private cache;
+    private listeners;
+    private unsubscribeAdapter;
+    version: number;
+    pending: boolean;
+    lastError: Error | null;
+    constructor(adapter: VfsAdapter<TMeta>, config: Partial<VfsEngineConfig<TMeta>> & {
+        sessionId: string;
+    });
+    init(strategy?: CacheStrategy): Promise<void>;
+    destroy(): void;
+    subscribe(onStoreChange: () => void): () => void;
+    execute(command: VfsCommand): Promise<void>;
+    private runCommand;
+    private runCreate;
+    private runRename;
+    private runDelete;
+    private runRestore;
+    private runPurge;
+    private runMove;
+    private runWrite;
+    private runLock;
+    private runUnlock;
+    private runReorder;
+    private runSnapshot;
+    getNode(id: string): Promise<VfsNode<TMeta> | null>;
+    getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getPath(id: string): Promise<string>;
+    readFile(id: string): Promise<Uint8Array>;
+    search(query: string, options?: {
+        scope?: string | null;
+        kind?: "file" | "folder";
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getTrashed(): Promise<VfsNode<TMeta>[]>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    private applySortOrder;
+    private autoSort;
+    private loadChildren;
+    private hydrateCache;
+    private cacheNode;
+    private evictNode;
+    private handleAdapterChange;
+    private resolveNode;
+    private assertNoDuplicate;
+    private extractTargetIds;
+    on<K extends keyof VfsEventMap<TMeta>>(event: K, listener: VfsEventListener<TMeta, K>): () => void;
+    emit<K extends keyof VfsEventMap<TMeta>>(event: K, payload: VfsEventMap<TMeta>[K]): void;
+    private emitChange;
+}
+
+export { VfsEngine as V, type VfsCommand as a, type VfsEventMap as b };

package/dist/VfsEngine-DLx0iUpi.d.ts

@@ -0,0 +1,152 @@
+import { V as VfsAdapter, a as VfsChange } from './VfsAdapter-DOBt_TyL.js';
+import { V as VfsEngineConfig, e as VfsNode, c as VfsFileSnapshot } from './VfsNode-D10gxL5W.js';
+
+type VfsCommand = {
+    op: "create";
+    kind: "file";
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "create";
+    kind: "folder";
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "rename";
+    id: string;
+    newName: string;
+} | {
+    op: "delete";
+    ids: string[];
+    permanent?: boolean;
+} | {
+    op: "restore";
+    ids: string[];
+} | {
+    op: "purge";
+    ids: string[];
+} | {
+    op: "move";
+    ids: string[];
+    newParentId: string | null;
+} | {
+    op: "write";
+    id: string;
+    content: Uint8Array;
+} | {
+    op: "lock";
+    ids: string[];
+} | {
+    op: "unlock";
+    ids: string[];
+} | {
+    op: "reorder";
+    parentId: string | null;
+    orderedIds: string[];
+} | {
+    op: "snapshot";
+    fileId: string;
+    label?: string;
+};
+type VfsEventMap<TMeta> = {
+    created: VfsNode<TMeta>;
+    renamed: VfsNode<TMeta>;
+    deleted: {
+        ids: string[];
+        permanent: boolean;
+    };
+    restored: VfsNode<TMeta>[];
+    purged: {
+        ids: string[];
+    };
+    moved: VfsNode<TMeta>[];
+    written: {
+        id: string;
+    };
+    locked: VfsNode<TMeta>[];
+    unlocked: VfsNode<TMeta>[];
+    reordered: {
+        parentId: string | null;
+        orderedIds: string[];
+    };
+    warning: {
+        code: string;
+        tabId?: string;
+        nodeId?: string;
+    };
+    snapshot: VfsFileSnapshot;
+    pending: {
+        command: VfsCommand;
+    };
+    settled: {
+        command: VfsCommand;
+        success: boolean;
+    };
+    error: {
+        command: VfsCommand;
+        error: Error;
+    };
+    change: VfsChange;
+};
+type VfsEventListener<TMeta, K extends keyof VfsEventMap<TMeta>> = (payload: VfsEventMap<TMeta>[K]) => void;
+type CacheStrategy = "eager" | "lazy" | "hybrid";
+declare class VfsEngine<TMeta extends Record<string, unknown> | undefined = Record<string, unknown>> {
+    private adapter;
+    private config;
+    private cache;
+    private listeners;
+    private unsubscribeAdapter;
+    version: number;
+    pending: boolean;
+    lastError: Error | null;
+    constructor(adapter: VfsAdapter<TMeta>, config: Partial<VfsEngineConfig<TMeta>> & {
+        sessionId: string;
+    });
+    init(strategy?: CacheStrategy): Promise<void>;
+    destroy(): void;
+    subscribe(onStoreChange: () => void): () => void;
+    execute(command: VfsCommand): Promise<void>;
+    private runCommand;
+    private runCreate;
+    private runRename;
+    private runDelete;
+    private runRestore;
+    private runPurge;
+    private runMove;
+    private runWrite;
+    private runLock;
+    private runUnlock;
+    private runReorder;
+    private runSnapshot;
+    getNode(id: string): Promise<VfsNode<TMeta> | null>;
+    getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getPath(id: string): Promise<string>;
+    readFile(id: string): Promise<Uint8Array>;
+    search(query: string, options?: {
+        scope?: string | null;
+        kind?: "file" | "folder";
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getTrashed(): Promise<VfsNode<TMeta>[]>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    private applySortOrder;
+    private autoSort;
+    private loadChildren;
+    private hydrateCache;
+    private cacheNode;
+    private evictNode;
+    private handleAdapterChange;
+    private resolveNode;
+    private assertNoDuplicate;
+    private extractTargetIds;
+    on<K extends keyof VfsEventMap<TMeta>>(event: K, listener: VfsEventListener<TMeta, K>): () => void;
+    emit<K extends keyof VfsEventMap<TMeta>>(event: K, payload: VfsEventMap<TMeta>[K]): void;
+    private emitChange;
+}
+
+export { VfsEngine as V, type VfsCommand as a, type VfsEventMap as b };