@treenity/core 1.0.48 → 3.0.1

package/src/tree/index.ts

@@ -0,0 +1,217 @@
+// Treenity Tree — Layer 1
+// Storage interface + in-memory implementation
+// Depends only on core types.
+
+import { isRef, type NodeData, type Ref, toStorageKeys } from '#core';
+import sift from 'sift';
+import { applyOps, defaultPatch, type PatchOp } from './patch';
+
+// ── Pagination ──
+
+export type PageOpts = { limit?: number; offset?: number };
+export type Page<T> = { items: T[]; total: number; queryMount?: { source: string, match: Record<string, unknown> } };
+
+export function paginate<T>(items: T[], opts?: PageOpts): Page<T> {
+  const total = items.length;
+  if (!opts?.limit) return { items, total };
+  const offset = opts.offset ?? 0;
+  return { items: items.slice(offset, offset + opts.limit), total };
+}
+
+// ── Interface ──
+
+export type ChildrenOpts = { depth?: number; query?: Record<string, unknown> } & PageOpts;
+
+export interface Tree {
+  get(path: string, ctx?: unknown): Promise<NodeData | undefined>;
+  getChildren(path: string, opts?: ChildrenOpts, ctx?: unknown): Promise<Page<NodeData>>;
+  set(node: NodeData, ctx?: unknown): Promise<void>;
+  remove(path: string, ctx?: unknown): Promise<boolean>;
+  patch(path: string, ops: PatchOp[], ctx?: unknown): Promise<void>;
+}
+
+// ── In-memory implementation ──
+
+// ── Ref resolution ──
+
+export async function resolveRef(store: Tree, node: NodeData): Promise<NodeData> {
+  if (!isRef(node)) return node;
+  const target = await store.get((node as unknown as Ref).$ref);
+  if (!target) throw new Error(`Ref not found: ${(node as unknown as Ref).$ref}`);
+  return target;
+}
+
+// ── Filter store ──
+// Like overlay, but set() routes to upper only when filter matches, else lower.
+// Reads merge both layers (upper wins). Remove tries both.
+// NOTE: limit/offset pagination is approximate — merging happens after both stores paginate.
+
+export function createFilterTree(
+  upper: Tree,
+  lower: Tree,
+  toUpper: (node: NodeData) => boolean,
+): Tree {
+  return {
+    async get(path, ctx) {
+      return (await upper.get(path, ctx)) ?? (await lower.get(path, ctx));
+    },
+    async getChildren(parent, opts, ctx) {
+      const passthrough = opts ? { depth: opts.depth, query: opts.query } : undefined;
+      const [u, l] = await Promise.all([
+        upper.getChildren(parent, passthrough, ctx),
+        lower.getChildren(parent, passthrough, ctx),
+      ]);
+      const byPath = new Map<string, NodeData>();
+      for (const n of l.items) byPath.set(n.$path, n);
+      for (const n of u.items) byPath.set(n.$path, n);
+      const result = paginate([...byPath.values()], opts);
+      // Forward queryMount from lower store (mount system → CDC Matrix)
+      if (l.queryMount) result.queryMount = l.queryMount;
+      return result;
+    },
+    async set(node, ctx) {
+      if (toUpper(node)) await upper.set(node, ctx);
+      else await lower.set(node, ctx);
+    },
+    async remove(path, ctx) {
+      const a = await upper.remove(path, ctx);
+      const b = await lower.remove(path, ctx);
+      return a || b;
+    },
+    async patch(path, ops, ctx) {
+      const node = await upper.get(path, ctx) ?? await lower.get(path, ctx);
+      if (!node) throw new Error(`Node not found: ${path}`);
+      if (toUpper(node)) await upper.patch(path, ops, ctx);
+      else await lower.patch(path, ops, ctx);
+    },
+  };
+}
+
+// ── Overlay store ──
+// Reads: upper first, fall back to lower. Writes: upper only.
+// Like createFilterTree(upper, lower, () => true) but remove only affects upper.
+
+export function createOverlayTree(upper: Tree, lower: Tree): Tree {
+  return {
+    ...createFilterTree(upper, lower, () => true),
+    async remove(path, ctx) {
+      return upper.remove(path, ctx);
+    },
+  };
+}
+
+// ── In-memory implementation ──
+
+function mapNodeForSift(node: NodeData): Record<string, unknown> {
+  return toStorageKeys(node);
+}
+
+export type TreeNode<T> = {
+  data?: T;
+  children: Map<string, TreeNode<T>>;
+};
+
+export function treeNavigate<T>(root: TreeNode<T>, path: string): TreeNode<T> | undefined {
+  if (path === '/') return root;
+  const parts = path.slice(1).split('/');
+  let node = root;
+  for (const part of parts) {
+    const child = node.children.get(part);
+    if (!child) return undefined;
+    node = child;
+  }
+  return node;
+}
+
+export function treeEnsure<T>(root: TreeNode<T>, path: string): TreeNode<T> {
+  if (path === '/') return root;
+  const parts = path.slice(1).split('/');
+  let node = root;
+  for (const part of parts) {
+    let child = node.children.get(part);
+    if (!child) {
+      child = { children: new Map() } as TreeNode<T>;
+      node.children.set(part, child);
+    }
+    node = child;
+  }
+  return node;
+}
+
+export function createMemoryTree(): Tree {
+  const root: TreeNode<NodeData> = { children: new Map() };
+  const navigate = (path: string) => treeNavigate(root, path);
+  const ensurePath = (path: string) => treeEnsure(root, path);
+
+  function collectChildren(
+    node: TreeNode<NodeData>,
+    parentPath: string,
+    maxDepth: number,
+    currentDepth: number = 1,
+  ): NodeData[] {
+    const result: NodeData[] = [];
+    if (currentDepth > maxDepth) return result;
+
+    for (const [name, child] of node.children) {
+      if (child.data) result.push(child.data);
+      if (currentDepth < maxDepth) {
+        const childPath = parentPath === '/' ? `/${name}` : `${parentPath}/${name}`;
+        result.push(...collectChildren(child, childPath, maxDepth, currentDepth + 1));
+      }
+    }
+    return result;
+  }
+
+  return {
+    async get(path, _ctx) {
+      if (typeof path !== 'string') throw new Error(`store.get: path must be string, got ${typeof path}`);
+      const data = navigate(path)?.data;
+      return data ? structuredClone(data) : data;
+    },
+
+    async getChildren(parent, opts, _ctx) {
+      const node = navigate(parent);
+      if (!node) return { items: [], total: 0 };
+      const depth = opts?.depth ?? 1;
+      let result = collectChildren(node, parent, depth);
+      if (opts?.query) {
+         const test = sift(opts.query);
+         result = result.filter(n => test(mapNodeForSift(n)));
+      }
+      return paginate(result, opts);
+    },
+
+    async set(node, _ctx) {
+      const treeNode = ensurePath(node.$path);
+
+      if (node.$rev != null) {
+        // OCC: caller knows about rev — must match stored
+        const prevRev = treeNode.data?.$rev;
+        if (node.$rev !== prevRev) {
+          throw new Error(`OptimisticConcurrencyError: node ${node.$path} modified by another transaction. Expected $rev ${prevRev}, got ${node.$rev}`);
+        }
+      }
+
+      node.$rev = (node.$rev ?? 0) + 1;
+      treeNode.data = structuredClone(node);
+    },
+
+    async remove(path, _ctx) {
+      const treeNode = navigate(path);
+      if (!treeNode?.data) return false;
+      treeNode.data = undefined;
+      return true;
+    },
+
+    async patch(path, ops, _ctx) {
+      const treeNode = navigate(path);
+      if (!treeNode?.data) throw new Error(`Node not found: ${path}`);
+      const copy = structuredClone(treeNode.data);
+      applyOps(copy, ops);
+      copy.$rev = (copy.$rev ?? 0) + 1;
+      treeNode.data = copy;
+    },
+  };
+}
+
+export { type PatchOp, type Rfc6902Op, PatchTestError, applyOps, toRfc6902, fromRfc6902, defaultPatch } from './patch';

package/src/tree/inflight.ts

@@ -0,0 +1,15 @@
+// Inflight dedup — async memoize that auto-clears on settle.
+// First caller runs fn(); concurrent callers share the same Promise.
+// Once resolved/rejected, entry is deleted so retries work.
+
+export function createInflight<V>(): (key: string, fn: () => Promise<V>) => Promise<V> {
+  const map = new Map<string, Promise<V>>();
+
+  return (key, fn) => {
+    let p = map.get(key);
+    if (p) return p;
+    p = fn().finally(() => map.delete(key));
+    map.set(key, p);
+    return p;
+  };
+}

package/src/tree/json-codec.ts

@@ -0,0 +1,16 @@
+// JSON file ↔ node codec for RawFS store
+// JSON files are plain objects — no metadata wrapping
+
+import type { NodeData } from '#core';
+import { register } from '#core';
+import { readFile } from 'node:fs/promises';
+
+export function registerJsonCodec() {
+  register('application/json', 'decode', async (filePath: string, nodePath: string) => {
+    const raw = await readFile(filePath, 'utf-8');
+    const obj = JSON.parse(raw);
+    return { ...obj, $path: nodePath, $type: obj.$type ?? 'application/json' } as NodeData;
+  });
+}
+
+registerJsonCodec();

package/src/tree/mimefs.test.ts

@@ -0,0 +1,289 @@
+import type { NodeData } from '#core';
+import { register } from '#core';
+import { clearRegistry } from '#core/index.test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { registerJsonCodec } from './json-codec';
+import { createRawFsStore } from './mimefs';
+
+describe('RawFsStore', () => {
+  let dir: string;
+
+  beforeEach(() => { clearRegistry(); registerJsonCodec(); });
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true });
+  });
+
+  async function setup() {
+    dir = await mkdtemp(join(tmpdir(), 'treenity-rawfs-test-'));
+    return createRawFsStore(dir);
+  }
+
+  it('file → typed node', async () => {
+    const store = await setup();
+    await writeFile(join(dir, 'photo.jpg'), 'fake-jpeg');
+    const node = await store.get('/photo.jpg');
+
+    assert.equal(node?.$path, '/photo.jpg');
+    assert.equal(node?.$type, 'image/jpeg');
+    assert.ok((node as any).meta?.size > 0);
+  });
+
+  it('directory → dir node', async () => {
+    const store = await setup();
+    await mkdir(join(dir, 'albums'));
+    const node = await store.get('/albums');
+
+    assert.equal(node?.$path, '/albums');
+    assert.equal(node?.$type, 'dir');
+  });
+
+  it('missing path → undefined', async () => {
+    const store = await setup();
+    assert.equal(await store.get('/nope'), undefined);
+  });
+
+  it('getChildren lists typed entries', async () => {
+    const store = await setup();
+    await writeFile(join(dir, 'a.txt'), 'text');
+    await writeFile(join(dir, 'b.csv'), 'col1,col2');
+    await mkdir(join(dir, 'sub'));
+
+    const { items } = await store.getChildren('/');
+    assert.equal(items.length, 3);
+
+    const byPath = Object.fromEntries(items.map(n => [n.$path, n.$type]));
+    assert.equal(byPath['/a.txt'], 'text/plain');
+    assert.equal(byPath['/b.csv'], 'text/csv');
+    assert.equal(byPath['/sub'], 'dir');
+  });
+
+  it('getChildren respects depth', async () => {
+    const store = await setup();
+    await mkdir(join(dir, 'a'));
+    await writeFile(join(dir, 'a', 'deep.md'), '# hello');
+
+    const d1 = await store.getChildren('/', { depth: 1 });
+    assert.equal(d1.items.length, 1);
+    assert.equal(d1.items[0].$type, 'dir');
+
+    const d2 = await store.getChildren('/', { depth: 2 });
+    assert.equal(d2.items.length, 2);
+  });
+
+  it('skips hidden files', async () => {
+    const store = await setup();
+    await writeFile(join(dir, '.hidden'), 'secret');
+    await writeFile(join(dir, 'visible.txt'), 'hi');
+
+    const { items } = await store.getChildren('/');
+    assert.equal(items.length, 1);
+    assert.equal(items[0].$path, '/visible.txt');
+  });
+
+  it('mime type detection', async () => {
+    const store = await setup();
+    const cases: [string, string][] = [
+      ['doc.pdf', 'application/pdf'],
+      ['style.css', 'text/css'],
+      ['data.json', 'application/json'],  // needs valid JSON — codec parses it
+      ['clip.mp4', 'video/mp4'],
+      ['song.mp3', 'audio/mpeg'],
+      ['page.html', 'text/html'],
+      ['notes.md', 'text/markdown'],
+      ['unknown.xyz', 'application/octet-stream'],
+    ];
+
+    for (const [name, expectedType] of cases) {
+      const content = name.endsWith('.json') ? '{}' : 'data';
+      await writeFile(join(dir, name), content);
+      const node = await store.get('/' + name);
+      assert.equal(node?.$type, expectedType, `${name} should be ${expectedType}`);
+    }
+  });
+
+  it('json file → parsed object, no meta', async () => {
+    const store = await setup();
+    await writeFile(join(dir, 'config.json'), JSON.stringify({ name: 'test', count: 42 }));
+    const node = await store.get('/config.json');
+
+    assert.equal(node?.$path, '/config.json');
+    assert.equal(node?.$type, 'application/json');
+    assert.equal((node as any).name, 'test');
+    assert.equal((node as any).count, 42);
+    assert.equal((node as any).meta, undefined);
+  });
+
+  it('json file preserves $type from content', async () => {
+    const store = await setup();
+    await writeFile(join(dir, 'typed.json'), JSON.stringify({ $type: 'my.custom', foo: 'bar' }));
+    const node = await store.get('/typed.json');
+
+    assert.equal(node?.$type, 'my.custom');
+    assert.equal((node as any).foo, 'bar');
+  });
+
+  it('custom decode enriches node', async () => {
+    const store = await setup();
+    await writeFile(join(dir, 'data.csv'), 'name,age\nalice,30\nbob,25');
+
+    register('text/csv', 'decode', async (filePath: string, nodePath: string) => {
+      const { readFile } = await import('node:fs/promises');
+      const content = await readFile(filePath, 'utf-8');
+      const lines = content.trim().split('\n');
+      return {
+        $path: nodePath,
+        $type: 'text/csv',
+        columns: lines[0].split(','),
+        rowCount: lines.length - 1,
+      } as any;
+    });
+
+    const node = await store.get('/data.csv');
+    assert.equal(node?.$type, 'text/csv');
+    assert.deepEqual((node as any).columns, ['name', 'age']);
+    assert.equal((node as any).rowCount, 2);
+
+  });
+
+  // --- Encode tests ---
+
+  it('set() with registered encode writes file', async () => {
+    const store = await setup();
+
+    register('text/plain', 'encode', async (node: NodeData, filePath: string) => {
+      await writeFile(filePath, (node as any).content ?? '');
+    });
+
+    await store.set({ $path: '/hello.txt', $type: 'text/plain', content: 'world' } as any);
+
+    const raw = await readFile(join(dir, 'hello.txt'), 'utf-8');
+    assert.equal(raw, 'world');
+
+  });
+
+  it('set() without encode throws', async () => {
+    const store = await setup();
+    await assert.rejects(
+      () => store.set({ $path: '/x.bin', $type: 'application/octet-stream' } as any),
+    );
+  });
+
+  it('set() creates parent directories', async () => {
+    const store = await setup();
+
+    register('text/plain', 'encode', async (node: NodeData, filePath: string) => {
+      await writeFile(filePath, 'nested');
+    });
+
+    await store.set({ $path: '/deep/nested/file.txt', $type: 'text/plain' } as any);
+
+    const raw = await readFile(join(dir, 'deep', 'nested', 'file.txt'), 'utf-8');
+    assert.equal(raw, 'nested');
+
+  });
+
+  it('remove() deletes file', async () => {
+    const store = await setup();
+    await writeFile(join(dir, 'gone.txt'), 'bye');
+
+    const result = await store.remove('/gone.txt');
+    assert.equal(result, true);
+    await assert.rejects(() => stat(join(dir, 'gone.txt')), { code: 'ENOENT' });
+  });
+
+  it('remove() missing file returns false', async () => {
+    const store = await setup();
+    const result = await store.remove('/nope.txt');
+    assert.equal(result, false);
+  });
+
+  it('remove() deletes empty directory', async () => {
+    const store = await setup();
+    await mkdir(join(dir, 'empty'));
+
+    const result = await store.remove('/empty');
+    assert.equal(result, true);
+    await assert.rejects(() => stat(join(dir, 'empty')), { code: 'ENOENT' });
+  });
+
+  // --- .env codec ---
+
+  it('.env file → application/x-env', async () => {
+    const store = await setup();
+    await writeFile(join(dir, 'config.env'), 'PORT=3000\nDB=treenity\n');
+
+    const node = await store.get('/config.env');
+    assert.equal(node?.$type, 'application/x-env');
+  });
+
+  it('.env roundtrip: decode → encode → decode', async () => {
+    const store = await setup();
+
+    // Register env decode
+    register('application/x-env', 'decode', async (filePath: string, nodePath: string) => {
+      const content = await readFile(filePath, 'utf-8');
+      const env: Record<string, string> = {};
+      for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eq = trimmed.indexOf('=');
+        if (eq === -1) continue;
+        env[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim();
+      }
+      return { $path: nodePath, $type: 'application/x-env', env } as any;
+    });
+
+    // Register env encode
+    register('application/x-env', 'encode', async (node: NodeData, filePath: string) => {
+      const env = (node as any).env as Record<string, string>;
+      if (!env) throw new Error('env component required');
+      const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`);
+      await writeFile(filePath, lines.join('\n') + '\n');
+    });
+
+    // Write via store
+    await store.set({
+      $path: '/config.env',
+      $type: 'application/x-env',
+      env: { PORT: '3000', DB_NAME: 'treenity', FEATURE_X: 'true' },
+    } as any);
+
+    // Verify file on disk
+    const raw = await readFile(join(dir, 'config.env'), 'utf-8');
+    assert.ok(raw.includes('PORT=3000'));
+    assert.ok(raw.includes('DB_NAME=treenity'));
+
+    // Read back via store — roundtrip
+    const node = await store.get('/config.env');
+    assert.equal(node?.$type, 'application/x-env');
+    assert.deepEqual((node as any).env, { PORT: '3000', DB_NAME: 'treenity', FEATURE_X: 'true' });
+
+  });
+
+  it('.env decode skips comments and empty lines', async () => {
+    const store = await setup();
+
+    register('application/x-env', 'decode', async (filePath: string, nodePath: string) => {
+      const content = await readFile(filePath, 'utf-8');
+      const env: Record<string, string> = {};
+      for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eq = trimmed.indexOf('=');
+        if (eq === -1) continue;
+        env[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim();
+      }
+      return { $path: nodePath, $type: 'application/x-env', env } as any;
+    });
+
+    await writeFile(join(dir, 'config.env'), '# comment\n\nKEY=value\n# another\nFOO=bar\n');
+    const node = await store.get('/config.env');
+    assert.deepEqual((node as any).env, { KEY: 'value', FOO: 'bar' });
+
+  });
+});

package/src/tree/mimefs.ts

@@ -0,0 +1,142 @@
+// Treenity RawFS Tree — Layer 1
+// Bidirectional store that maps real filesystem files to typed nodes.
+// Files become nodes with $type from mime type. Directories become $type "dir".
+// "decode" context: file → node (read). "encode" context: node → file (write).
+
+import type { NodeData } from '#core';
+import { resolve as ctxResolve } from '#core/registry';
+import { mkdir, readdir, rmdir, stat, unlink } from 'node:fs/promises';
+import { dirname, extname, join, resolve } from 'node:path';
+import type { Tree } from './index';
+import { paginate } from './index';
+import './json-codec'; // register JSON decode handler
+import { defaultPatch } from './patch';
+
+const MIME: Record<string, string> = {
+  '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+  '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon', '.bmp': 'image/bmp',
+  '.mp4': 'video/mp4', '.webm': 'video/webm', '.mov': 'video/quicktime',
+  '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.ogg': 'audio/ogg', '.flac': 'audio/flac',
+  '.pdf': 'application/pdf', '.zip': 'application/zip', '.gz': 'application/gzip',
+  '.json': 'application/json', '.xml': 'application/xml', '.yaml': 'application/yaml',
+  '.yml': 'application/yaml',
+  '.csv': 'text/csv', '.txt': 'text/plain', '.md': 'text/markdown',
+  '.html': 'text/html', '.css': 'text/css',
+  '.js': 'text/javascript', '.ts': 'text/typescript', '.tsx': 'text/typescript',
+  '.py': 'text/x-python', '.sh': 'text/x-shellscript',
+  '.env': 'application/x-env',
+};
+
+function getMime(filename: string): string {
+  return MIME[extname(filename).toLowerCase()] ?? 'application/octet-stream';
+}
+
+export type DecodeHandler = (filePath: string, nodePath: string) => Promise<NodeData>;
+export type EncodeHandler = (node: NodeData, filePath: string) => Promise<void>;
+
+declare module '#core/context' {
+  interface ContextHandlers {
+    decode: DecodeHandler;
+    encode: EncodeHandler;
+  }
+}
+
+export async function createRawFsStore(rootDir: string): Promise<Tree> {
+  rootDir = resolve(rootDir);
+
+  function toFilePath(path: string): string {
+    const full = resolve(join(rootDir, path));
+    if (!full.startsWith(rootDir)) throw new Error(`Path traversal blocked`);
+    return full;
+  }
+
+  async function fileToNode(filePath: string, nodePath: string): Promise<NodeData> {
+    const st = await stat(filePath);
+
+    if (st.isDirectory()) {
+      return { $path: nodePath, $type: 'dir' } as NodeData;
+    }
+
+    const mime = getMime(filePath);
+
+    const decode = ctxResolve(mime, 'decode');
+    if (decode) return decode(filePath, nodePath);
+
+    return {
+      $path: nodePath,
+      $type: mime,
+      meta: { size: st.size, modified: st.mtime.toISOString(), created: st.birthtime.toISOString() },
+    } as NodeData;
+  }
+
+  const tree: Tree = {
+    async get(path) {
+      const file = toFilePath(path);
+      try {
+        return await fileToNode(file, path);
+      } catch (e: any) {
+        if (e.code === 'ENOENT') return undefined;
+        throw e;
+      }
+    },
+
+    async getChildren(parent, opts) {
+      const dir = toFilePath(parent);
+      const depth = opts?.depth ?? 1;
+
+      const results: NodeData[] = [];
+
+      async function walk(dirPath: string, parentNodePath: string, currentDepth: number) {
+        if (currentDepth > depth) return;
+        let entries;
+        try { entries = await readdir(dirPath, { withFileTypes: true }); } catch { return; }
+
+        for (const e of entries) {
+          if (e.name.startsWith('.')) continue; // skip hidden files
+          const filePath = join(dirPath, e.name);
+          const nodePath = parentNodePath === '/' ? `/${e.name}` : `${parentNodePath}/${e.name}`;
+          results.push(await fileToNode(filePath, nodePath));
+
+          if (e.isDirectory() && currentDepth < depth) {
+            await walk(filePath, nodePath, currentDepth + 1);
+          }
+        }
+      }
+
+      await walk(dir, parent, 1);
+      return paginate(results, opts);
+    },
+
+    async set(node) {
+      const filePath = toFilePath(node.$path);
+      const encode = ctxResolve(node.$type, 'encode');
+      if (!encode) throw new Error(`No encode registered for type "${node.$type}"`);
+
+      await mkdir(dirname(filePath), { recursive: true });
+      await encode(node, filePath);
+    },
+
+    async remove(path) {
+      const filePath = toFilePath(path);
+      try {
+        const st = await stat(filePath);
+        if (st.isDirectory()) {
+          await rmdir(filePath);
+        } else {
+          await unlink(filePath);
+        }
+        return true;
+      } catch (e: any) {
+        if (e.code === 'ENOENT') return false;
+        throw e;
+      }
+    },
+
+    async patch(path, ops, ctx) {
+      return defaultPatch(tree.get, tree.set, path, ops, ctx);
+    },
+  };
+
+  return tree;
+}