@struktoai/mirage-browser 0.0.5-alpha.1 → 0.0.6

package/dist/chunk-UFHBDBZD.js

@@ -1,1212 +0,0 @@
-// src/resource/opfs/opfs.ts
-import {
-  ResourceName as ResourceName18,
-  lstripSlash,
-  makeResolveGlob,
-  compareCodePoints as compareCodePoints4
-} from "@struktoai/mirage-core";
-
-// src/accessor/opfs.ts
-import { Accessor } from "@struktoai/mirage-core";
-var OPFSAccessor = class extends Accessor {
-  provider;
-  constructor(provider) {
-    super();
-    this.provider = provider;
-  }
-  get rootHandle() {
-    return this.provider.requireHandle();
-  }
-};
-
-// src/commands/builtin/opfs/index.ts
-import { ResourceName as ResourceName6, makeGenericCommands } from "@struktoai/mirage-core";
-
-// src/core/opfs/append.ts
-import { record, ResourceName } from "@struktoai/mirage-core";
-
-// src/core/opfs/utils.ts
-import { enoent, enotdir } from "@struktoai/mirage-core";
-import { norm, parent, gnuBasename } from "@struktoai/mirage-core";
-function splitSegments(virtual) {
-  const parts = [];
-  for (const seg of virtual.split("/")) {
-    if (seg === "" || seg === ".") continue;
-    if (seg === "..") {
-      if (parts.length === 0) {
-        throw new Error(`path escapes root: ${virtual}`);
-      }
-      parts.pop();
-      continue;
-    }
-    parts.push(seg);
-  }
-  return parts;
-}
-async function resolveDirHandle(root, virtual, options = {}) {
-  const segs = splitSegments(virtual);
-  let handle = root;
-  for (const seg of segs) {
-    handle = await handle.getDirectoryHandle(seg, { create: options.create ?? false });
-  }
-  return handle;
-}
-async function resolveFileHandle(root, virtual, options = {}) {
-  const segs = splitSegments(virtual);
-  const fileName = segs.pop();
-  if (fileName === void 0) {
-    throw new Error(`not a file: ${virtual}`);
-  }
-  let dir = root;
-  for (const seg of segs) {
-    dir = await dir.getDirectoryHandle(seg, { create: false });
-  }
-  return dir.getFileHandle(fileName, { create: options.create ?? false });
-}
-async function resolveParentDirHandle(root, virtual, options = {}) {
-  const segs = splitSegments(virtual);
-  const name = segs.pop();
-  if (name === void 0) {
-    throw new Error(`no parent directory: ${virtual}`);
-  }
-  let dir = root;
-  for (const seg of segs) {
-    dir = await dir.getDirectoryHandle(seg, { create: options.create ?? false });
-  }
-  return [dir, name];
-}
-function destError(err, spec) {
-  if (isNotFound(err)) return enoent(spec);
-  if (isTypeMismatch(err)) return enotdir(spec);
-  return err;
-}
-async function kindAt(root, key) {
-  let dir;
-  let name;
-  try {
-    ;
-    [dir, name] = await resolveParentDirHandle(root, key, { create: false });
-  } catch (err) {
-    if (!isNotFound(err) && !isTypeMismatch(err)) throw err;
-    return null;
-  }
-  try {
-    await dir.getDirectoryHandle(name, { create: false });
-    return "dir";
-  } catch (err) {
-    if (!isNotFound(err) && !isTypeMismatch(err)) throw err;
-  }
-  try {
-    await dir.getFileHandle(name, { create: false });
-    return "file";
-  } catch (err) {
-    if (!isNotFound(err) && !isTypeMismatch(err)) throw err;
-  }
-  return null;
-}
-function isNotFound(err) {
-  if (err instanceof DOMException) {
-    return err.name === "NotFoundError";
-  }
-  return false;
-}
-function isTypeMismatch(err) {
-  if (err instanceof DOMException) {
-    return err.name === "TypeMismatchError";
-  }
-  return false;
-}
-function toWritableChunk(data) {
-  const copy2 = new Uint8Array(data.byteLength);
-  copy2.set(data);
-  return new Blob([copy2]);
-}
-async function* iterEntries(dir) {
-  const iter = dir.entries();
-  for await (const [name, handle] of iter) {
-    yield [name, handle];
-  }
-}
-
-// src/core/opfs/append.ts
-async function appendBytes(accessor, p, data) {
-  const root = accessor.rootHandle;
-  const start = performance.now();
-  const virtual = p.mountPath;
-  let handle;
-  try {
-    handle = await resolveFileHandle(root, virtual, { create: true });
-  } catch (err) {
-    throw destError(err, p);
-  }
-  const existing = await handle.getFile();
-  const existingBytes = new Uint8Array(await existing.arrayBuffer());
-  const merged = new Uint8Array(existingBytes.byteLength + data.byteLength);
-  merged.set(existingBytes, 0);
-  merged.set(data, existingBytes.byteLength);
-  const writable = await handle.createWritable();
-  await writable.write(toWritableChunk(merged));
-  await writable.close();
-  record("append", virtual, ResourceName.OPFS, data.byteLength, start);
-}
-
-// src/core/opfs/constants.ts
-var SCOPE_ERROR = 5e4;
-
-// src/core/opfs/copy.ts
-import { enoent as enoent2 } from "@struktoai/mirage-core";
-async function copy(accessor, src, dst) {
-  const root = accessor.rootHandle;
-  let srcHandle;
-  try {
-    srcHandle = await resolveFileHandle(root, src.mountPath, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent2(src);
-    throw err;
-  }
-  const file = await srcHandle.getFile();
-  const data = new Uint8Array(await file.arrayBuffer());
-  let dstHandle;
-  try {
-    dstHandle = await resolveFileHandle(root, dst.mountPath, { create: true });
-  } catch (err) {
-    throw destError(err, dst);
-  }
-  const writable = await dstHandle.createWritable();
-  await writable.write(toWritableChunk(data));
-  await writable.close();
-}
-
-// src/core/opfs/write.ts
-import { record as record2, ResourceName as ResourceName2 } from "@struktoai/mirage-core";
-async function writeBytes(accessor, p, data) {
-  const root = accessor.rootHandle;
-  const start = performance.now();
-  const virtual = p.mountPath;
-  let handle;
-  try {
-    handle = await resolveFileHandle(root, virtual, { create: true });
-  } catch (err) {
-    throw destError(err, p);
-  }
-  const writable = await handle.createWritable();
-  await writable.write(toWritableChunk(data));
-  await writable.close();
-  record2("write", virtual, ResourceName2.OPFS, data.byteLength, start);
-}
-
-// src/core/opfs/create.ts
-function create(accessor, path) {
-  return writeBytes(accessor, path, new Uint8Array());
-}
-
-// src/core/opfs/du/walk.ts
-async function walkSizes(dir) {
-  let total = 0;
-  for await (const [name, handle] of iterEntries(dir)) {
-    if (handle.kind === "file") {
-      try {
-        const fh = await dir.getFileHandle(name, { create: false });
-        const file = await fh.getFile();
-        total += file.size;
-      } catch {
-      }
-    } else {
-      try {
-        const child = await dir.getDirectoryHandle(name, { create: false });
-        total += await walkSizes(child);
-      } catch {
-      }
-    }
-  }
-  return total;
-}
-async function walkAll(dir, currentPath, entries2) {
-  let total = 0;
-  for await (const [name, handle] of iterEntries(dir)) {
-    const childPath = currentPath === "/" ? `/${name}` : `${currentPath}/${name}`;
-    if (handle.kind === "file") {
-      try {
-        const fh = await dir.getFileHandle(name, { create: false });
-        const file = await fh.getFile();
-        entries2.push([childPath, file.size]);
-        total += file.size;
-      } catch {
-      }
-    } else {
-      try {
-        const child = await dir.getDirectoryHandle(name, { create: false });
-        total += await walkAll(child, childPath, entries2);
-      } catch {
-      }
-    }
-  }
-  return total;
-}
-async function sizeOfPath(root, virtual) {
-  try {
-    const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
-    try {
-      const fh = await parentDir.getFileHandle(name, { create: false });
-      const file = await fh.getFile();
-      return file.size;
-    } catch (err) {
-      if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
-        throw err;
-      }
-    }
-    const dir = await parentDir.getDirectoryHandle(name, { create: false });
-    return await walkSizes(dir);
-  } catch (err) {
-    if (isNotFound(err)) return 0;
-    if (err instanceof Error && err.message.startsWith("no parent directory")) {
-      try {
-        const rootDir = await resolveDirHandle(root, virtual, { create: false });
-        return await walkSizes(rootDir);
-      } catch {
-        return 0;
-      }
-    }
-    throw err;
-  }
-}
-
-// src/core/opfs/du/entries.ts
-import { compareCodePoints } from "@struktoai/mirage-core";
-async function entries(accessor, p) {
-  const root = accessor.rootHandle;
-  const virtual = norm(p.mountPath);
-  const entries2 = [];
-  try {
-    const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
-    try {
-      const fh = await parentDir.getFileHandle(name, { create: false });
-      const file = await fh.getFile();
-      entries2.push([virtual, file.size]);
-      return [entries2, file.size];
-    } catch (err) {
-      if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
-        throw err;
-      }
-    }
-    const dir = await parentDir.getDirectoryHandle(name, { create: false });
-    const total = await walkAll(dir, virtual, entries2);
-    entries2.sort((a, b) => compareCodePoints(a[0], b[0]));
-    return [entries2, total];
-  } catch (err) {
-    if (isNotFound(err)) return [entries2, 0];
-    if (err instanceof Error && err.message.startsWith("no parent directory")) {
-      try {
-        const rootDir = await resolveDirHandle(root, virtual, { create: false });
-        const total = await walkAll(rootDir, virtual, entries2);
-        entries2.sort((a, b) => compareCodePoints(a[0], b[0]));
-        return [entries2, total];
-      } catch {
-        return [entries2, 0];
-      }
-    }
-    throw err;
-  }
-}
-
-// src/core/opfs/du/size.ts
-async function size(accessor, p) {
-  return sizeOfPath(accessor.rootHandle, p.mountPath);
-}
-
-// src/core/opfs/exists.ts
-async function exists(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  if (virtual === "/" || virtual === "") return true;
-  try {
-    const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
-    try {
-      await parentDir.getFileHandle(name, { create: false });
-      return true;
-    } catch (err) {
-      if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
-        throw err;
-      }
-    }
-    try {
-      await parentDir.getDirectoryHandle(name, { create: false });
-      return true;
-    } catch (err) {
-      if (isNotFound(err) || err instanceof DOMException && err.name === "TypeMismatchError") {
-        return false;
-      }
-      throw err;
-    }
-  } catch (err) {
-    if (isNotFound(err)) return false;
-    if (isTypeMismatch(err)) return false;
-    if (err instanceof Error && err.message.startsWith("path escapes root")) return false;
-    if (err instanceof Error && err.message.startsWith("no parent directory")) {
-      try {
-        await resolveDirHandle(root, virtual, { create: false });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    throw err;
-  }
-}
-
-// src/core/opfs/find.ts
-import {
-  buildTree,
-  emitStartPath,
-  keep,
-  startBasename,
-  compareCodePoints as compareCodePoints2
-} from "@struktoai/mirage-core";
-async function walk(ctx, dir, current, depth) {
-  const opts = ctx.options;
-  if (opts.maxDepth !== null && opts.maxDepth !== void 0 && depth > opts.maxDepth) return;
-  let iter;
-  try {
-    iter = iterEntries(dir);
-  } catch {
-    return;
-  }
-  for await (const [entryName, handle] of iter) {
-    const kind = handle.kind === "directory" ? "d" : "f";
-    const entryPath = current === "/" ? `/${entryName}` : `${current}/${entryName}`;
-    const entryDepth = depth + 1;
-    let accept = true;
-    if (opts.maxDepth !== null && opts.maxDepth !== void 0 && entryDepth > opts.maxDepth) {
-      accept = false;
-    }
-    let isEmpty = null;
-    if (accept && opts.empty === true) {
-      try {
-        if (kind === "f") {
-          isEmpty = (await handle.getFile()).size === 0;
-        } else {
-          isEmpty = true;
-          for await (const _child of iterEntries(handle)) {
-            void _child;
-            isEmpty = false;
-            break;
-          }
-        }
-      } catch {
-        isEmpty = null;
-      }
-    }
-    if (accept && !keep(
-      { key: entryPath, name: entryName, kind, depth: entryDepth, isEmpty },
-      ctx.tree,
-      opts.minDepth
-    )) {
-      accept = false;
-    }
-    if (accept && kind !== "f" && (opts.minSize != null || opts.maxSize != null)) {
-      if (opts.minSize != null && opts.minSize > 0) accept = false;
-      if (opts.maxSize != null && opts.maxSize < 0) accept = false;
-    }
-    if (accept && kind === "f" && (opts.minSize !== null || opts.maxSize !== null || opts.mtimeMin !== null || opts.mtimeMax !== null)) {
-      try {
-        const fh = await dir.getFileHandle(entryName, { create: false });
-        const file = await fh.getFile();
-        if (opts.minSize !== null && opts.minSize !== void 0 && file.size < opts.minSize)
-          accept = false;
-        if (opts.maxSize !== null && opts.maxSize !== void 0 && file.size > opts.maxSize)
-          accept = false;
-        if (accept && (opts.mtimeMin !== void 0 || opts.mtimeMax !== void 0)) {
-          const mtime = file.lastModified / 1e3;
-          if (opts.mtimeMin !== null && opts.mtimeMin !== void 0 && mtime < opts.mtimeMin)
-            accept = false;
-          if (opts.mtimeMax !== null && opts.mtimeMax !== void 0 && mtime > opts.mtimeMax)
-            accept = false;
-        }
-      } catch {
-        accept = false;
-      }
-    }
-    if (accept) ctx.results.push(entryPath);
-    if (kind === "d") {
-      try {
-        const child = await dir.getDirectoryHandle(entryName, { create: false });
-        await walk(ctx, child, entryPath, depth + 1);
-      } catch {
-      }
-    }
-  }
-}
-async function find(accessor, p, options = {}) {
-  const root = accessor.rootHandle;
-  const virtual = norm(p.mountPath);
-  const startName = startBasename(p.virtual);
-  const results = [];
-  const tree = options.tree ?? buildTree({
-    name: options.name,
-    iname: options.iname,
-    pathPattern: options.pathPattern,
-    type: options.type,
-    nameExclude: options.nameExclude,
-    orNames: options.orNames,
-    empty: options.empty
-  });
-  let dir;
-  try {
-    dir = await resolveDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) return results;
-    throw err;
-  }
-  if (options.maxDepth == null || options.maxDepth >= 0) {
-    let rootEmpty = null;
-    if (options.empty === true) {
-      rootEmpty = true;
-      for await (const _child of iterEntries(dir)) {
-        void _child;
-        rootEmpty = false;
-        break;
-      }
-    }
-    emitStartPath(results, virtual, startName, {
-      kind: "d",
-      isEmpty: rootEmpty,
-      exists: true,
-      tree,
-      maxDepth: options.maxDepth,
-      minDepth: options.minDepth,
-      minSize: options.minSize,
-      maxSize: options.maxSize
-    });
-  }
-  await walk({ options, tree, results }, dir, virtual, 0);
-  results.sort(compareCodePoints2);
-  return results;
-}
-
-// src/core/opfs/mkdir.ts
-import {
-  ancestors,
-  eexist,
-  enotdir as enotdir2,
-  invalidateAfterWrite,
-  invalidateAncestors,
-  mountedPath,
-  norm as norm2
-} from "@struktoai/mirage-core";
-async function checkMkdirTarget(root, spec, key, parents) {
-  if (!parents) {
-    if (await kindAt(root, key) !== null) throw eexist(spec);
-    return;
-  }
-  for (const component of [...ancestors(key), key]) {
-    if (await kindAt(root, component) !== "file") continue;
-    const named = mountedPath(spec, component);
-    throw component === key ? eexist(named) : enotdir2(named);
-  }
-}
-async function mkdir(accessor, path, parents = false) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  const segs = splitSegments(virtual);
-  if (segs.length === 0) return;
-  await checkMkdirTarget(root, path, norm2(virtual), parents);
-  if (parents) {
-    await resolveDirHandle(root, virtual, { create: true });
-    await invalidateAfterWrite(path);
-    await invalidateAncestors(path);
-    return;
-  }
-  let parentDir;
-  let name;
-  try {
-    ;
-    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    throw destError(err, path);
-  }
-  await parentDir.getDirectoryHandle(name, { create: true });
-  await invalidateAfterWrite(path);
-}
-
-// src/core/opfs/read.ts
-import { record as record3, ResourceName as ResourceName3 } from "@struktoai/mirage-core";
-import { eisdir, enoent as enoent3 } from "@struktoai/mirage-core";
-async function read(accessor, path) {
-  const root = accessor.rootHandle;
-  const start = performance.now();
-  const virtual = path.mountPath;
-  let handle;
-  try {
-    handle = await resolveFileHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent3(path);
-    if (err instanceof DOMException && err.name === "TypeMismatchError") throw eisdir(path);
-    throw err;
-  }
-  const file = await handle.getFile();
-  const bytes = new Uint8Array(await file.arrayBuffer());
-  record3("read", virtual, ResourceName3.OPFS, bytes.byteLength, start);
-  return bytes;
-}
-
-// src/core/opfs/readdir.ts
-import { compareCodePoints as compareCodePoints3, mountPrefixOf } from "@struktoai/mirage-core";
-import { enoent as enoent4, enotdir as enotdir3 } from "@struktoai/mirage-core";
-async function readdir(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.pattern !== null ? path.directory : path.mountPath;
-  let dir;
-  try {
-    dir = await resolveDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent4(path);
-    if (isTypeMismatch(err)) throw enotdir3(path);
-    throw err;
-  }
-  const names = [];
-  for await (const [name] of iterEntries(dir)) {
-    names.push(name);
-  }
-  const base = norm(virtual);
-  const dirPrefix = base === "/" ? "/" : `${base}/`;
-  const mountPrefix = mountPrefixOf(path.virtual, path.resourcePath);
-  return names.map((n) => `${mountPrefix}${dirPrefix}${n}`).sort(compareCodePoints3);
-}
-
-// src/core/opfs/rename.ts
-import { enoent as enoent5 } from "@struktoai/mirage-core";
-async function copyDirRecursive(root, srcPath, dstPath) {
-  const srcDir = await resolveDirHandle(root, srcPath, { create: false });
-  const dstDir = await resolveDirHandle(root, dstPath, { create: true });
-  for await (const [name, handle] of iterEntries(srcDir)) {
-    if (handle.kind === "file") {
-      const srcFile = await srcDir.getFileHandle(name, { create: false });
-      const file = await srcFile.getFile();
-      const data = new Uint8Array(await file.arrayBuffer());
-      const dstFile = await dstDir.getFileHandle(name, { create: true });
-      const writable = await dstFile.createWritable();
-      await writable.write(toWritableChunk(data));
-      await writable.close();
-    } else {
-      await copyDirRecursive(root, `${srcPath}/${name}`, `${dstPath}/${name}`);
-    }
-  }
-}
-async function rename(accessor, src, dst) {
-  const root = accessor.rootHandle;
-  const srcPath = src.mountPath;
-  const dstPath = dst.mountPath;
-  let srcParent;
-  let srcName;
-  try {
-    ;
-    [srcParent, srcName] = await resolveParentDirHandle(root, srcPath, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent5(src);
-    throw err;
-  }
-  let isFile = false;
-  try {
-    await srcParent.getFileHandle(srcName, { create: false });
-    isFile = true;
-  } catch (err) {
-    if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
-      throw err;
-    }
-  }
-  if (!isFile) {
-    try {
-      await srcParent.getDirectoryHandle(srcName, { create: false });
-    } catch (err) {
-      if (isNotFound(err)) throw enoent5(src);
-      throw err;
-    }
-  }
-  try {
-    await resolveParentDirHandle(root, dstPath, { create: false });
-  } catch (err) {
-    throw destError(err, dst);
-  }
-  if (isFile) {
-    const srcFile = await resolveFileHandle(root, srcPath, { create: false });
-    const file = await srcFile.getFile();
-    const data = new Uint8Array(await file.arrayBuffer());
-    let dstFile;
-    try {
-      dstFile = await resolveFileHandle(root, dstPath, { create: true });
-    } catch (err) {
-      throw destError(err, dst);
-    }
-    const writable = await dstFile.createWritable();
-    await writable.write(toWritableChunk(data));
-    await writable.close();
-    await srcParent.removeEntry(srcName);
-    return;
-  }
-  await copyDirRecursive(root, srcPath, dstPath);
-  await srcParent.removeEntry(srcName, { recursive: true });
-}
-
-// src/core/opfs/rm.ts
-async function rmR(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  let parentDir;
-  let name;
-  try {
-    ;
-    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) return;
-    if (err instanceof Error && err.message.startsWith("no parent directory")) return;
-    throw err;
-  }
-  try {
-    await parentDir.removeEntry(name, { recursive: true });
-  } catch (err) {
-    if (isNotFound(err)) return;
-    throw err;
-  }
-}
-
-// src/core/opfs/rmdir.ts
-async function rmdir(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  let parentDir;
-  let name;
-  try {
-    ;
-    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) return;
-    if (err instanceof Error && err.message.startsWith("no parent directory")) return;
-    throw err;
-  }
-  try {
-    await parentDir.removeEntry(name, { recursive: false });
-  } catch (err) {
-    if (isNotFound(err)) return;
-    throw err;
-  }
-}
-
-// src/core/opfs/stat.ts
-import { FileStat, FileType, guessType } from "@struktoai/mirage-core";
-async function stat(accessor, p) {
-  const root = accessor.rootHandle;
-  const virtual = p.mountPath;
-  const segs = splitSegments(virtual);
-  const last = segs.at(-1);
-  if (last === void 0) {
-    return new FileStat({
-      name: "/",
-      size: null,
-      modified: null,
-      type: FileType.DIRECTORY
-    });
-  }
-  const name = last;
-  let parentDir;
-  let entryName;
-  try {
-    ;
-    [parentDir, entryName] = await resolveParentDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    throw destError(err, p);
-  }
-  try {
-    const fileHandle = await parentDir.getFileHandle(entryName, { create: false });
-    const file = await fileHandle.getFile();
-    const modified = new Date(file.lastModified).toISOString();
-    return new FileStat({
-      name,
-      size: file.size,
-      modified,
-      fingerprint: modified,
-      type: guessType(name)
-    });
-  } catch (err) {
-    if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
-      throw err;
-    }
-  }
-  let dirHandle;
-  try {
-    dirHandle = await resolveDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    throw destError(err, p);
-  }
-  let latest = 0;
-  for await (const [, handle] of iterEntries(dirHandle)) {
-    if (handle.kind !== "file") continue;
-    const file = await handle.getFile();
-    if (file.lastModified > latest) latest = file.lastModified;
-  }
-  return new FileStat({
-    name,
-    size: null,
-    modified: latest > 0 ? new Date(latest).toISOString() : null,
-    type: FileType.DIRECTORY
-  });
-}
-
-// src/core/opfs/stream.ts
-import { recordStream, ResourceName as ResourceName4 } from "@struktoai/mirage-core";
-import { eisdir as eisdir2, enoent as enoent6 } from "@struktoai/mirage-core";
-async function* stream(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  let handle;
-  try {
-    handle = await resolveFileHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent6(path);
-    if (err instanceof DOMException && err.name === "TypeMismatchError") throw eisdir2(path);
-    throw err;
-  }
-  const file = await handle.getFile();
-  const rec = recordStream("read", virtual, ResourceName4.OPFS);
-  const reader = file.stream().getReader();
-  for (; ; ) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    if (rec !== null) rec.bytes += value.byteLength;
-    yield value;
-  }
-}
-
-// src/core/opfs/truncate.ts
-import { ResourceName as ResourceName5, record as record4 } from "@struktoai/mirage-core";
-async function truncate(accessor, path, length) {
-  const start = performance.now();
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  let handle;
-  let existing;
-  try {
-    handle = await resolveFileHandle(root, virtual, { create: false });
-    const file = await handle.getFile();
-    existing = new Uint8Array(await file.arrayBuffer());
-  } catch (err) {
-    if (isNotFound(err)) {
-      try {
-        handle = await resolveFileHandle(root, virtual, { create: true });
-      } catch (cerr) {
-        throw destError(cerr, path);
-      }
-      existing = new Uint8Array();
-    } else {
-      throw destError(err, path);
-    }
-  }
-  const out = new Uint8Array(length);
-  out.set(existing.subarray(0, Math.min(existing.byteLength, length)));
-  const writable = await handle.createWritable();
-  await writable.write(toWritableChunk(out));
-  await writable.close();
-  record4("truncate", virtual, ResourceName5.OPFS, 0, start);
-}
-
-// src/core/opfs/unlink.ts
-async function unlink(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  let parentDir;
-  let name;
-  try {
-    ;
-    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) return;
-    if (err instanceof Error && err.message.startsWith("no parent directory")) return;
-    throw err;
-  }
-  try {
-    await parentDir.removeEntry(name);
-  } catch (err) {
-    if (isNotFound(err)) return;
-    throw err;
-  }
-}
-
-// src/commands/builtin/opfs/io.ts
-var OPFS_IO = {
-  readdir,
-  readBytes: read,
-  readStream: stream,
-  stat,
-  isMounted: () => true,
-  local: true,
-  maxGlobMatches: SCOPE_ERROR,
-  write: writeBytes,
-  exists,
-  mkdir,
-  unlink,
-  rmdir,
-  rmR,
-  rename,
-  copy,
-  create,
-  truncate,
-  append: appendBytes,
-  find,
-  du: { size, entries }
-};
-
-// src/commands/builtin/opfs/index.ts
-var OPFS_COMMANDS = [
-  ...makeGenericCommands(ResourceName6.OPFS, OPFS_IO)
-];
-
-// src/ops/opfs/append.ts
-import { ResourceName as ResourceName7 } from "@struktoai/mirage-core";
-var appendOp = {
-  name: "append",
-  resource: ResourceName7.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const data = args[0];
-    if (!(data instanceof Uint8Array)) {
-      throw new TypeError("append op requires a Uint8Array as the first arg");
-    }
-    return appendBytes(accessor, path, data);
-  }
-};
-
-// src/ops/opfs/create.ts
-import { ResourceName as ResourceName8 } from "@struktoai/mirage-core";
-var createOp = {
-  name: "create",
-  resource: ResourceName8.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => create(accessor, path)
-};
-
-// src/ops/opfs/mkdir.ts
-import { ResourceName as ResourceName9 } from "@struktoai/mirage-core";
-var mkdirOp = {
-  name: "mkdir",
-  resource: ResourceName9.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => mkdir(accessor, path, true)
-};
-
-// src/ops/opfs/read.ts
-import { ResourceName as ResourceName10 } from "@struktoai/mirage-core";
-var readOp = {
-  name: "read",
-  resource: ResourceName10.OPFS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => read(accessor, path)
-};
-
-// src/ops/opfs/readdir.ts
-import { ResourceName as ResourceName11 } from "@struktoai/mirage-core";
-var readdirOp = {
-  name: "readdir",
-  resource: ResourceName11.OPFS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => readdir(accessor, path)
-};
-
-// src/ops/opfs/rename.ts
-import { ResourceName as ResourceName12 } from "@struktoai/mirage-core";
-var renameOp = {
-  name: "rename",
-  resource: ResourceName12.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const dst = args[0];
-    if (dst === void 0 || dst === null || typeof dst !== "object" || !("virtual" in dst)) {
-      throw new TypeError("rename op requires a PathSpec destination as the first arg");
-    }
-    return rename(accessor, path, dst);
-  }
-};
-
-// src/ops/opfs/rmdir.ts
-import { ResourceName as ResourceName13 } from "@struktoai/mirage-core";
-var rmdirOp = {
-  name: "rmdir",
-  resource: ResourceName13.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => rmdir(accessor, path)
-};
-
-// src/ops/opfs/stat.ts
-import { ResourceName as ResourceName14 } from "@struktoai/mirage-core";
-var statOp = {
-  name: "stat",
-  resource: ResourceName14.OPFS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => stat(accessor, path)
-};
-
-// src/ops/opfs/truncate.ts
-import { ResourceName as ResourceName15 } from "@struktoai/mirage-core";
-var truncateOp = {
-  name: "truncate",
-  resource: ResourceName15.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const length = args[0];
-    if (typeof length !== "number") {
-      throw new TypeError("truncate op requires a number length as the first arg");
-    }
-    return truncate(accessor, path, length);
-  }
-};
-
-// src/ops/opfs/unlink.ts
-import { ResourceName as ResourceName16 } from "@struktoai/mirage-core";
-var unlinkOp = {
-  name: "unlink",
-  resource: ResourceName16.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => unlink(accessor, path)
-};
-
-// src/ops/opfs/write.ts
-import { ResourceName as ResourceName17 } from "@struktoai/mirage-core";
-var writeOp = {
-  name: "write",
-  resource: ResourceName17.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const data = args[0];
-    if (!(data instanceof Uint8Array)) {
-      throw new TypeError("write op requires a Uint8Array as the first arg");
-    }
-    return writeBytes(accessor, path, data);
-  }
-};
-
-// src/ops/opfs/index.ts
-var OPFS_OPS = [
-  appendOp,
-  createOp,
-  mkdirOp,
-  readOp,
-  readdirOp,
-  renameOp,
-  rmdirOp,
-  statOp,
-  truncateOp,
-  unlinkOp,
-  writeOp
-];
-
-// src/resource/opfs/prompt.ts
-var OPFS_PROMPT = `{prefix}
-  Browser Origin Private File System. Persistent per-origin storage that survives page reloads.
-  Standard commands: ls, cat, head, tail, grep, wc, find, tree, mkdir, touch, cp, mv, rm, tee.`;
-
-// src/resource/opfs/opfs.ts
-var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
-async function walkFiles(dir, currentPath, files) {
-  for await (const [name, handle] of iterEntries(dir)) {
-    const childPath = currentPath === "" ? name : `${currentPath}/${name}`;
-    if (handle.kind === "file") {
-      const fh = await dir.getFileHandle(name, { create: false });
-      const file = await fh.getFile();
-      files[childPath] = new Uint8Array(await file.arrayBuffer());
-    } else {
-      const child = await dir.getDirectoryHandle(name, { create: false });
-      await walkFiles(child, childPath, files);
-    }
-  }
-}
-async function walkDirs(dir, currentPath, dirs) {
-  for await (const [name, handle] of iterEntries(dir)) {
-    if (handle.kind !== "directory") continue;
-    const childPath = currentPath === "" ? `/${name}` : `${currentPath}/${name}`;
-    dirs.push(childPath);
-    const child = await dir.getDirectoryHandle(name, { create: false });
-    await walkDirs(child, childPath, dirs);
-  }
-}
-async function splitAndCreate(root, relativePath) {
-  let handle = root;
-  for (const seg of relativePath.split("/")) {
-    if (seg === "" || seg === ".") continue;
-    handle = await handle.getDirectoryHandle(seg, { create: true });
-  }
-  return handle;
-}
-var OPFSResource = class {
-  kind = ResourceName18.OPFS;
-  // OPFS is a real filesystem: getFile().size is the exact byte count a
-  // read returns.
-  sizesAlwaysKnown = true;
-  prompt = OPFS_PROMPT;
-  rootName;
-  accessor;
-  rootHandle = null;
-  openPromise = null;
-  constructor(options = {}) {
-    this.rootName = options.root ?? "";
-    this.accessor = new OPFSAccessor(this);
-  }
-  open() {
-    return this.ensureOpen().then(() => void 0);
-  }
-  close() {
-    this.rootHandle = null;
-    this.openPromise = null;
-    return Promise.resolve();
-  }
-  /**
-   * Lazily resolve to a usable root handle. Memoizes `navigator.storage`
-   * traversal so the resource self-initializes on first method call without
-   * relying on an external orchestrator.
-   */
-  ensureOpen() {
-    if (this.rootHandle !== null) return Promise.resolve(this.rootHandle);
-    this.openPromise ??= (async () => {
-      const origin = await navigator.storage.getDirectory();
-      let handle = origin;
-      for (const seg of this.rootName.split("/")) {
-        if (seg === "" || seg === ".") continue;
-        handle = await handle.getDirectoryHandle(seg, { create: true });
-      }
-      this.rootHandle = handle;
-      return handle;
-    })();
-    return this.openPromise;
-  }
-  requireHandle() {
-    if (this.rootHandle === null) {
-      throw new Error("OPFSResource is not open \u2014 call open() first");
-    }
-    return this.rootHandle;
-  }
-  ops() {
-    return OPFS_OPS;
-  }
-  commands() {
-    return OPFS_COMMANDS;
-  }
-  async *streamPath(p) {
-    await this.ensureOpen();
-    yield* stream(this.accessor, p);
-  }
-  async readFile(p) {
-    await this.ensureOpen();
-    return read(this.accessor, p);
-  }
-  async writeFile(p, data) {
-    await this.ensureOpen();
-    return writeBytes(this.accessor, p, data);
-  }
-  async appendFile(p, data) {
-    await this.ensureOpen();
-    return appendBytes(this.accessor, p, data);
-  }
-  async readdir(p) {
-    await this.ensureOpen();
-    return readdir(this.accessor, p);
-  }
-  async stat(p) {
-    await this.ensureOpen();
-    return stat(this.accessor, p);
-  }
-  async exists(p) {
-    await this.ensureOpen();
-    return exists(this.accessor, p);
-  }
-  async mkdir(p, options) {
-    await this.ensureOpen();
-    return mkdir(this.accessor, p, options?.recursive === true);
-  }
-  async rmdir(p) {
-    await this.ensureOpen();
-    return rmdir(this.accessor, p);
-  }
-  async unlink(p) {
-    await this.ensureOpen();
-    return unlink(this.accessor, p);
-  }
-  async rename(src, dst) {
-    await this.ensureOpen();
-    return rename(this.accessor, src, dst);
-  }
-  async truncate(p, length) {
-    await this.ensureOpen();
-    return truncate(this.accessor, p, length);
-  }
-  async copy(src, dst) {
-    await this.ensureOpen();
-    return copy(this.accessor, src, dst);
-  }
-  async rmR(p) {
-    await this.ensureOpen();
-    return rmR(this.accessor, p);
-  }
-  async du(p) {
-    await this.ensureOpen();
-    return size(this.accessor, p);
-  }
-  async find(p, options = {}) {
-    await this.ensureOpen();
-    return find(this.accessor, p, options);
-  }
-  async glob(paths) {
-    await this.ensureOpen();
-    return globCore(this.accessor, paths);
-  }
-  async getState() {
-    const handle = await this.ensureOpen();
-    const files = {};
-    await walkFiles(handle, "", files);
-    const dirs = [];
-    await walkDirs(handle, "", dirs);
-    dirs.sort(compareCodePoints4);
-    return {
-      type: this.kind,
-      files,
-      dirs
-    };
-  }
-  async loadState(state) {
-    const handle = await this.ensureOpen();
-    for (const dir of state.dirs) {
-      const rel = lstripSlash(dir);
-      if (rel === "") continue;
-      await splitAndCreate(handle, rel);
-    }
-    for (const [rel, data] of Object.entries(state.files)) {
-      const segs = rel.split("/").filter((s) => s !== "" && s !== ".");
-      const fileName = segs.pop();
-      if (fileName === void 0) continue;
-      let dir = handle;
-      for (const seg of segs) {
-        dir = await dir.getDirectoryHandle(seg, { create: true });
-      }
-      const fh = await dir.getFileHandle(fileName, { create: true });
-      const writable = await fh.createWritable();
-      await writable.write(toWritableChunk(data));
-      await writable.close();
-    }
-  }
-};
-
-export {
-  OPFSAccessor,
-  OPFS_COMMANDS,
-  OPFS_OPS,
-  OPFS_PROMPT,
-  OPFSResource
-};
-//# sourceMappingURL=chunk-UFHBDBZD.js.map