@struktoai/mirage-node 0.0.3 → 0.0.5-alpha.1

package/dist/chunk-DDAFNROK.js

@@ -0,0 +1,750 @@
+import {
+  loadOptionalPeer
+} from "./chunk-OQKNDS66.js";
+
+// src/accessor/hf.ts
+import { Accessor, ResourceName } from "@struktoai/mirage-core";
+var HF_RESOURCES = [
+  ResourceName.HF_BUCKETS,
+  ResourceName.HF_DATASETS,
+  ResourceName.HF_MODELS,
+  ResourceName.HF_SPACES
+];
+var HfAccessor = class extends Accessor {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  config;
+  operatorPromise = null;
+  get repoId() {
+    const config = this.config;
+    return config.repoId ?? config.bucket ?? "";
+  }
+  operatorOptions() {
+    const options = {
+      repo_type: this.repoType,
+      repo_id: this.repoId
+    };
+    if (this.config.token !== void 0 && this.config.token !== "") {
+      options.token = this.config.token;
+    }
+    if (this.config.endpoint !== void 0 && this.config.endpoint !== "") {
+      options.endpoint = this.config.endpoint;
+    }
+    const keyPrefix = this.config.keyPrefix;
+    if (keyPrefix !== void 0 && keyPrefix !== "") {
+      options.root = `/${stripSlashes(keyPrefix)}/`;
+    }
+    const revision = this.config.revision;
+    if (revision !== void 0 && revision !== "") {
+      options.revision = revision;
+    }
+    return options;
+  }
+  operator() {
+    this.operatorPromise ??= this.createOperator();
+    return this.operatorPromise;
+  }
+  async createOperator() {
+    const mod = await loadOptionalPeer(
+      () => import("opendal"),
+      { feature: "HuggingFace resources", packageName: "opendal" }
+    );
+    return new mod.Operator("hf", this.operatorOptions());
+  }
+};
+function stripSlashes(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && value[start] === "/") start += 1;
+  while (end > start && value[end - 1] === "/") end -= 1;
+  return value.slice(start, end);
+}
+var HfBucketsAccessor = class extends HfAccessor {
+  repoType = "bucket";
+  resourceName = ResourceName.HF_BUCKETS;
+  get bucketUri() {
+    return `hf://buckets/${this.repoId}`;
+  }
+};
+var HfDatasetsAccessor = class extends HfAccessor {
+  repoType = "dataset";
+  resourceName = ResourceName.HF_DATASETS;
+  get bucketUri() {
+    return `hf://datasets/${this.repoId}`;
+  }
+};
+var HfModelsAccessor = class extends HfAccessor {
+  repoType = "model";
+  resourceName = ResourceName.HF_MODELS;
+  get bucketUri() {
+    return `hf://models/${this.repoId}`;
+  }
+};
+var HfSpacesAccessor = class extends HfAccessor {
+  repoType = "space";
+  resourceName = ResourceName.HF_SPACES;
+  get bucketUri() {
+    return `hf://spaces/${this.repoId}`;
+  }
+};
+
+// src/commands/builtin/hf/index.ts
+import { makeGenericCommands } from "@struktoai/mirage-core";
+
+// src/commands/builtin/hf/find.ts
+import { command, findGeneric, metadataProvision, specOf } from "@struktoai/mirage-core";
+
+// src/core/hf/find.ts
+import {
+  buildTree,
+  emitStartPath,
+  keep,
+  rstripSlash,
+  startBasename,
+  stripSlash,
+  compareCodePoints
+} from "@struktoai/mirage-core";
+
+// src/core/hf/util.ts
+import { mountPrefixOf } from "@struktoai/mirage-core";
+function rawPathOf(path) {
+  const prefix = mountPrefixOf(path.virtual, path.resourcePath);
+  return prefix !== "" && path.virtual.startsWith(prefix) ? path.virtual.slice(prefix.length) || "/" : path.virtual;
+}
+function hfKey(rawPath) {
+  let start = 0;
+  while (start < rawPath.length && rawPath[start] === "/") start += 1;
+  return rawPath.slice(start);
+}
+function isNotFound(err) {
+  return err instanceof Error && err.message.startsWith("NotFound");
+}
+
+// src/core/hf/find.ts
+function matchesFilters(entryPath, kind, size2, isEmpty, baseDepth, options, tree) {
+  const entryName = entryPath.split("/").pop() ?? "";
+  const depth = (entryPath.match(/\//g) ?? []).length - baseDepth;
+  if (options.maxDepth !== null && options.maxDepth !== void 0 && depth > options.maxDepth) {
+    return false;
+  }
+  if (!keep({ key: entryPath, name: entryName, kind, depth, isEmpty }, tree, options.minDepth)) {
+    return false;
+  }
+  if (options.minSize != null || options.maxSize != null) {
+    const effective = kind === "f" ? size2 : 0;
+    if (options.minSize != null && effective < options.minSize) {
+      return false;
+    }
+    if (options.maxSize != null && effective > options.maxSize) {
+      return false;
+    }
+  }
+  return true;
+}
+async function find(accessor, path, options = {}) {
+  const target = rawPathOf(path);
+  const pfx = stripSlash(target);
+  const scanPath = pfx !== "" ? `${pfx}/` : "/";
+  const base = pfx !== "" ? `/${pfx}` : "/";
+  const baseDepth = base === "/" ? 0 : (base.match(/\//g) ?? []).length;
+  const startName = startBasename(path.virtual);
+  const empty = options.empty === true;
+  const op = await accessor.operator();
+  const results = [];
+  const seenDirs = /* @__PURE__ */ new Set();
+  let sawDescendant = false;
+  let dirExists = false;
+  const tree = options.tree ?? buildTree({
+    name: options.name,
+    iname: options.iname,
+    pathPattern: options.pathPattern,
+    type: options.type,
+    nameExclude: options.nameExclude,
+    orNames: options.orNames
+  });
+  let entries2;
+  try {
+    entries2 = await op.list(scanPath, { recursive: true });
+  } catch (err) {
+    if (isNotFound(err)) return [];
+    throw err;
+  }
+  for (const entry of entries2) {
+    const rel = entry.path();
+    if (rel === "") continue;
+    const meta = entry.metadata();
+    const isDir = rel.endsWith("/") || meta.isDirectory();
+    const entryPath = `/${stripSlash(rel)}`;
+    if (entryPath === base) {
+      dirExists = true;
+      continue;
+    }
+    sawDescendant = true;
+    const kind = isDir ? "d" : "f";
+    const length = meta.contentLength;
+    const size2 = length !== null ? Number(length) : 0;
+    const fileEntries = [[entryPath, kind]];
+    if (!isDir) {
+      let parent = rstripSlash(entryPath.slice(0, entryPath.lastIndexOf("/"))) || "/";
+      while (parent !== "" && parent !== base && parent !== "/") {
+        if (!seenDirs.has(parent)) {
+          seenDirs.add(parent);
+          fileEntries.push([parent, "d"]);
+        }
+        parent = parent.slice(0, parent.lastIndexOf("/")) || "/";
+      }
+    }
+    for (const [ep, k] of fileEntries) {
+      const isEmpty = !empty ? null : k === "d" ? false : size2 === 0;
+      if (matchesFilters(ep, k, size2, isEmpty, baseDepth, options, tree)) {
+        results.push(ep);
+      }
+    }
+  }
+  if (sawDescendant || dirExists) {
+    emitStartPath(results, base, startName, {
+      kind: "d",
+      isEmpty: !sawDescendant,
+      exists: true,
+      tree,
+      maxDepth: options.maxDepth,
+      minDepth: options.minDepth,
+      minSize: options.minSize,
+      maxSize: options.maxSize
+    });
+  }
+  return [...new Set(results)].sort(compareCodePoints);
+}
+
+// src/core/hf/readdir.ts
+import {
+  IndexEntry,
+  ResourceType,
+  mountPrefixOf as mountPrefixOf2,
+  rstripSlash as rstripSlash2,
+  stripSlash as stripSlash2,
+  compareCodePoints as compareCodePoints2
+} from "@struktoai/mirage-core";
+
+// src/core/hf/constants.ts
+var SCOPE_ERROR = 1e4;
+var DEFAULT_CHUNK_SIZE = 8192;
+
+// src/core/hf/readdir.ts
+import { enoent } from "@struktoai/mirage-core";
+async function readdir(accessor, path, index) {
+  const prefix = mountPrefixOf2(path.virtual, path.resourcePath);
+  let target = path.pattern !== null ? path.directory : path.virtual;
+  if (prefix !== "" && target.startsWith(prefix)) {
+    const rest = target.slice(prefix.length);
+    if (prefix.endsWith("/") || rest === "" || rest.startsWith("/")) {
+      target = rest || "/";
+    }
+  }
+  const virtualKey = rstripSlash2(prefix !== "" ? `${prefix}${target}` : target) || "/";
+  if (index !== void 0) {
+    const listing = await index.listDir(virtualKey);
+    if (listing.entries !== void 0 && listing.entries !== null) {
+      return listing.entries;
+    }
+  }
+  const strippedTarget = stripSlash2(target);
+  const listPath = strippedTarget !== "" ? `${strippedTarget}/` : "/";
+  const op = await accessor.operator();
+  const names = [];
+  const dirKeys = /* @__PURE__ */ new Set();
+  const sizes = /* @__PURE__ */ new Map();
+  let entries2;
+  try {
+    entries2 = await op.list(listPath);
+  } catch (err) {
+    if (isNotFound(err)) throw enoent(path);
+    throw err;
+  }
+  for (const entry of entries2) {
+    const relative = entry.path();
+    if (relative === "" || relative === listPath) continue;
+    const isDir = relative.endsWith("/");
+    const base = `/${rstripSlash2(relative)}`;
+    names.push(base);
+    if (isDir) {
+      dirKeys.add(base);
+    } else {
+      const meta = entry.metadata();
+      const length = meta.contentLength;
+      sizes.set(base, length !== null ? Number(length) : null);
+    }
+  }
+  for (const [base, size2] of sizes) {
+    if (size2 !== null) continue;
+    const md = await op.stat(stripSlash2(base));
+    sizes.set(base, md.contentLength !== null ? Number(md.contentLength) : null);
+  }
+  names.sort(compareCodePoints2);
+  if (names.length > SCOPE_ERROR) {
+    console.warn(
+      `hf readdir: ${virtualKey} returned ${String(names.length)} entries (limit ${String(SCOPE_ERROR)})`
+    );
+  }
+  const virtualEntries = names.map((e) => prefix !== "" ? `${prefix}${e}` : e).sort(compareCodePoints2);
+  if (index !== void 0) {
+    const indexEntries = names.map((e) => {
+      const name = e.split("/").pop() ?? e;
+      if (dirKeys.has(e)) {
+        return [name, new IndexEntry({ id: e, name, resourceType: ResourceType.FOLDER })];
+      }
+      return [
+        name,
+        new IndexEntry({
+          id: e,
+          name,
+          resourceType: ResourceType.FILE,
+          size: sizes.get(e) ?? null
+        })
+      ];
+    });
+    await index.setDir(virtualKey, indexEntries);
+  }
+  return virtualEntries;
+}
+
+// src/commands/builtin/hf/find.ts
+var HF_FIND = command({
+  name: "find",
+  resource: [...HF_RESOURCES],
+  spec: specOf("find"),
+  provision: metadataProvision,
+  // The emptiness probe is wired like the generic builder does it, because
+  // a bucket start point that holds nothing is exactly what an object store
+  // cannot tell from a missing one, and `-empty` has to match it.
+  fn: (accessor, paths, texts, opts) => findGeneric(
+    paths,
+    texts,
+    opts,
+    (root, options) => find(accessor, root, options),
+    void 0,
+    async (spec) => (await readdir(accessor, spec, opts.index ?? void 0)).length === 0
+  )
+});
+
+// src/commands/builtin/hf/io.ts
+import { rangeOf } from "@struktoai/mirage-core";
+
+// src/core/hf/write.ts
+import { invalidateAfterWrite } from "@struktoai/mirage-core";
+import { invalidateAncestors } from "@struktoai/mirage-core";
+import { record } from "@struktoai/mirage-core";
+import { enoent as enoent2 } from "@struktoai/mirage-core";
+async function write(accessor, path, data, _index) {
+  const rawPath = rawPathOf(path);
+  const key = hfKey(rawPath);
+  const op = await accessor.operator();
+  const startMs = performance.now();
+  try {
+    await op.write(key, Buffer.from(data));
+  } catch (err) {
+    if (isNotFound(err)) throw enoent2(path);
+    throw err;
+  }
+  record("write", path.virtual, accessor.resourceName, data.byteLength, startMs);
+  await invalidateAfterWrite(path);
+  await invalidateAncestors(path);
+}
+
+// src/core/hf/create.ts
+async function create(accessor, path, index) {
+  await write(accessor, path, new Uint8Array(), index);
+}
+
+// src/core/hf/du/entries.ts
+import { compareCodePoints as compareCodePoints3, FileType as FileType2, stripSlash as stripSlash4 } from "@struktoai/mirage-core";
+
+// src/core/hf/du/walk.ts
+import "@struktoai/mirage-core";
+
+// src/core/hf/stat.ts
+import {
+  FileStat,
+  FileType,
+  guessType,
+  mountPrefixOf as mountPrefixOf3,
+  stripSlash as stripSlash3
+} from "@struktoai/mirage-core";
+import { enoent as enoent3 } from "@struktoai/mirage-core";
+async function stat(accessor, path, index) {
+  const prefix = mountPrefixOf3(path.virtual, path.resourcePath);
+  const rawPath = rawPathOf(path);
+  const stripped = stripSlash3(rawPath);
+  if (stripped === "") {
+    return new FileStat({ name: "/", type: FileType.DIRECTORY });
+  }
+  if (index !== void 0) {
+    const virtualKey = prefix !== "" ? `${prefix}/${stripped}` : `/${stripped}`;
+    const lookup = await index.get(virtualKey);
+    if (lookup.entry !== void 0 && lookup.entry !== null) {
+      const entry = lookup.entry;
+      if (entry.resourceType === "folder") {
+        return new FileStat({ name: entry.name, type: FileType.DIRECTORY });
+      }
+      return new FileStat({
+        name: entry.name,
+        size: entry.size ?? null,
+        type: guessType(entry.name)
+      });
+    }
+    const parent = virtualKey.slice(0, virtualKey.lastIndexOf("/")) || "/";
+    const parentListing = await index.listDir(parent);
+    if (parentListing.entries !== void 0 && parentListing.entries !== null) {
+      throw enoent3(path);
+    }
+  }
+  const op = await accessor.operator();
+  let md = null;
+  try {
+    md = await op.stat(stripped);
+  } catch (err) {
+    if (!isNotFound(err)) throw err;
+  }
+  if (md !== null && !md.isDirectory()) {
+    const etag = md.etag;
+    return new FileStat({
+      name: stripped.split("/").pop() ?? stripped,
+      size: md.contentLength !== null ? Number(md.contentLength) : null,
+      modified: md.lastModified,
+      type: guessType(rawPath),
+      fingerprint: etag,
+      extra: etag !== null && etag !== "" ? { etag } : {}
+    });
+  }
+  try {
+    const children = await op.list(`${stripped}/`);
+    if (children.length > 0) {
+      return new FileStat({
+        name: stripped.split("/").pop() ?? "/",
+        type: FileType.DIRECTORY
+      });
+    }
+  } catch (err) {
+    if (!isNotFound(err)) throw err;
+  }
+  throw enoent3(path);
+}
+
+// src/core/hf/du/walk.ts
+async function statOrNull(accessor, path) {
+  try {
+    return await stat(accessor, path);
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function lstrip(value) {
+  let start = 0;
+  while (start < value.length && value[start] === "/") start += 1;
+  return value.slice(start);
+}
+
+// src/core/hf/du/entries.ts
+async function entries(accessor, path) {
+  const info = await statOrNull(accessor, path);
+  if (info !== null && info.type !== FileType2.DIRECTORY) return [[], info.size ?? 0];
+  const target = rawPathOf(path);
+  const pfx = stripSlash4(target);
+  const scanPath = pfx !== "" ? `${pfx}/` : "/";
+  const op = await accessor.operator();
+  const results = [];
+  let total = 0;
+  try {
+    for (const entry of await op.list(scanPath, { recursive: true })) {
+      const rel = entry.path();
+      if (rel === "" || rel.endsWith("/")) continue;
+      const length = entry.metadata().contentLength;
+      const size2 = length !== null ? Number(length) : 0;
+      results.push([`/${lstrip(rel)}`, size2]);
+      total += size2;
+    }
+  } catch (err) {
+    if (!isNotFound(err)) throw err;
+  }
+  results.sort((a, b) => compareCodePoints3(a[0], b[0]));
+  return [results, total];
+}
+
+// src/core/hf/du/size.ts
+import { FileType as FileType3, stripSlash as stripSlash5 } from "@struktoai/mirage-core";
+async function size(accessor, path) {
+  const info = await statOrNull(accessor, path);
+  if (info !== null && info.type !== FileType3.DIRECTORY) return info.size ?? 0;
+  const target = rawPathOf(path);
+  const pfx = stripSlash5(target);
+  const scanPath = pfx !== "" ? `${pfx}/` : "/";
+  const op = await accessor.operator();
+  let total = 0;
+  try {
+    for (const entry of await op.list(scanPath, { recursive: true })) {
+      if (entry.path().endsWith("/")) continue;
+      const length = entry.metadata().contentLength;
+      total += length !== null ? Number(length) : 0;
+    }
+  } catch (err) {
+    if (isNotFound(err)) return 0;
+    throw err;
+  }
+  return total;
+}
+
+// src/core/hf/mkdir.ts
+async function mkdir(_accessor, _path, _index) {
+}
+
+// src/core/hf/unlink.ts
+import { invalidateAfterUnlink } from "@struktoai/mirage-core";
+import { FileType as FileType4, record as record2 } from "@struktoai/mirage-core";
+import { invalidateAncestors as invalidateAncestors2 } from "@struktoai/mirage-core";
+import { enoent as enoent4 } from "@struktoai/mirage-core";
+async function unlink(accessor, path, index) {
+  const fileStat = await stat(accessor, path, index);
+  const rawPath = rawPathOf(path);
+  if (fileStat.type === FileType4.DIRECTORY) {
+    const e = new Error(`EISDIR: ${rawPath}`);
+    e.code = "EISDIR";
+    throw e;
+  }
+  const key = hfKey(rawPath);
+  const op = await accessor.operator();
+  const startMs = performance.now();
+  try {
+    await op.delete(key);
+  } catch (err) {
+    if (isNotFound(err)) throw enoent4(path);
+    throw err;
+  }
+  record2("unlink", path.virtual, accessor.resourceName, 0, startMs);
+  await invalidateAfterUnlink(path);
+  await invalidateAncestors2(path);
+}
+
+// src/core/hf/read.ts
+import { record as record3 } from "@struktoai/mirage-core";
+import { enoent as enoent5 } from "@struktoai/mirage-core";
+async function read(accessor, path, _index, options = {}) {
+  const virtual = path.virtual;
+  const rawPath = rawPathOf(path);
+  const key = hfKey(rawPath);
+  const op = await accessor.operator();
+  const readOptions = {};
+  if (options.offset !== void 0 && options.offset > 0) {
+    readOptions.offset = BigInt(options.offset);
+  }
+  if (options.size !== void 0) {
+    readOptions.offset ??= 0n;
+    readOptions.size = BigInt(options.size);
+  }
+  const startMs = performance.now();
+  let data;
+  try {
+    data = readOptions.offset !== void 0 || readOptions.size !== void 0 ? await op.read(key, readOptions) : await op.read(key);
+  } catch (err) {
+    if (isNotFound(err)) throw enoent5(path);
+    throw err;
+  }
+  const bytes = new Uint8Array(data);
+  record3("read", virtual, accessor.resourceName, bytes.byteLength, startMs);
+  return bytes;
+}
+
+// src/core/hf/rm.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink2, record as record4, stripSlash as stripSlash6 } from "@struktoai/mirage-core";
+import { invalidateAncestors as invalidateAncestors3 } from "@struktoai/mirage-core";
+async function rmR(accessor, path) {
+  const stripped = stripSlash6(rawPathOf(path));
+  const scanPath = stripped !== "" ? `${stripped}/` : "/";
+  const op = await accessor.operator();
+  const startMs = performance.now();
+  const entries2 = await op.list(scanPath, { recursive: true });
+  for (const entry of entries2) {
+    const key = entry.path();
+    if (key.endsWith("/")) continue;
+    await op.delete(key);
+  }
+  record4("rm_r", path.virtual, accessor.resourceName, 0, startMs);
+  await invalidateAfterUnlink2(path);
+  await invalidateAncestors3(path);
+}
+
+// src/core/hf/stream.ts
+import { recordStream } from "@struktoai/mirage-core";
+import { enoent as enoent6 } from "@struktoai/mirage-core";
+async function rangeRead(accessor, path, start, end) {
+  return read(accessor, path, void 0, { offset: start, size: end - start });
+}
+async function* stream(accessor, path, _index, chunkSize = DEFAULT_CHUNK_SIZE) {
+  const virtual = path.virtual;
+  const rawPath = rawPathOf(path);
+  const key = hfKey(rawPath);
+  const op = await accessor.operator();
+  const rec = recordStream("read", virtual, accessor.resourceName);
+  let reader;
+  try {
+    reader = await op.reader(key);
+  } catch (err) {
+    if (isNotFound(err)) throw enoent6(path);
+    throw err;
+  }
+  const buf = Buffer.alloc(chunkSize);
+  for (; ; ) {
+    const n = Number(await reader.read(buf));
+    if (n <= 0) break;
+    const chunk = new Uint8Array(buf.subarray(0, n));
+    if (rec !== null) rec.bytes += chunk.byteLength;
+    yield chunk;
+  }
+}
+
+// src/core/hf/exists.ts
+async function exists(accessor, path) {
+  try {
+    await stat(accessor, path);
+    return true;
+  } catch (err) {
+    if (err?.code === "ENOENT") return false;
+    throw err;
+  }
+}
+
+// src/commands/builtin/hf/io.ts
+var HF_IO = {
+  readdir,
+  readBytes: read,
+  readRange: rangeOf(read),
+  readStream: stream,
+  stat,
+  du: { size, entries },
+  isMounted: () => true,
+  local: false,
+  maxGlobMatches: SCOPE_ERROR,
+  write,
+  exists,
+  mkdir: (accessor, path) => mkdir(accessor, path),
+  unlink,
+  rmR,
+  create
+};
+
+// src/commands/builtin/hf/index.ts
+var HF_OVERRIDES = /* @__PURE__ */ new Set(["cp", "mv", "find"]);
+var HF_COMMANDS = [
+  ...HF_RESOURCES.flatMap(
+    (resource) => makeGenericCommands(resource, HF_IO, {
+      overrides: HF_OVERRIDES
+    })
+  ),
+  ...HF_FIND
+];
+
+// src/ops/hf/index.ts
+import { makeGenericOps } from "@struktoai/mirage-core";
+var HF_OPS = makeGenericOps(HF_RESOURCES, HF_IO, {});
+
+// src/resource/hf_buckets/base.ts
+import {
+  BaseResource,
+  PathSpec,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf4
+} from "@struktoai/mirage-core";
+var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
+var HfResource = class extends BaseResource {
+  cachesReads = true;
+  // The Hub tree API reports each file's exact byte size (the LFS
+  // object size for LFS files); readdir backfills any lister-omitted
+  // size with one stat.
+  sizesAlwaysKnown = true;
+  supportsSnapshot = true;
+  opsMap = {
+    read_bytes: read,
+    readdir,
+    stat,
+    read_stream: stream,
+    range_read: rangeRead,
+    du_size: size,
+    du_entries: entries,
+    exists,
+    find_flat: find,
+    write,
+    create,
+    unlink,
+    mkdir
+  };
+  open() {
+    return Promise.resolve();
+  }
+  commands() {
+    return HF_COMMANDS;
+  }
+  ops() {
+    return HF_OPS;
+  }
+  streamPath(p) {
+    return stream(this.accessor, p);
+  }
+  readFile(p) {
+    return read(this.accessor, p, this.index);
+  }
+  writeFile(p, data) {
+    return write(this.accessor, p, data, this.index);
+  }
+  readdir(p) {
+    return readdir(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return stat(this.accessor, p, this.index);
+  }
+  exists(p) {
+    return exists(this.accessor, p);
+  }
+  mkdir(p) {
+    return mkdir(this.accessor, p);
+  }
+  unlink(p) {
+    return unlink(this.accessor, p, this.index);
+  }
+  du(p) {
+    return size(this.accessor, p);
+  }
+  find(p, options = {}) {
+    return find(this.accessor, p, options);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix ? paths.map(
+      (p) => mountPrefixOf4(p.virtual, p.resourcePath) ? p : new PathSpec({
+        virtual: p.virtual,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        resourcePath: mountKey(p.virtual, prefix)
+      })
+    ) : paths;
+    return globCore(this.accessor, effective, this.index);
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  HF_RESOURCES,
+  HfAccessor,
+  HfBucketsAccessor,
+  HfDatasetsAccessor,
+  HfModelsAccessor,
+  HfSpacesAccessor,
+  HF_COMMANDS,
+  HF_OPS,
+  HfResource
+};
+//# sourceMappingURL=chunk-DDAFNROK.js.map