@struktoai/mirage-node 0.0.3 → 0.0.4

package/dist/chunk-ZPZQXHW2.js

@@ -0,0 +1,1230 @@
+import {
+  redactNextcloudConfig
+} from "./chunk-MRXTUFBZ.js";
+import {
+  loadOptionalPeer
+} from "./chunk-OQKNDS66.js";
+
+// src/resource/nextcloud/nextcloud.ts
+import {
+  BaseResource,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf4,
+  PathSpec,
+  ResourceName as ResourceName7
+} from "@struktoai/mirage-core";
+
+// src/accessor/nextcloud.ts
+import { Accessor, ResourceName } from "@struktoai/mirage-core";
+var NextcloudAccessor = class extends Accessor {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  config;
+  resourceName = ResourceName.NEXTCLOUD;
+  operatorPromise = null;
+  operator() {
+    this.operatorPromise ??= this.createOperator();
+    return this.operatorPromise;
+  }
+  async createOperator() {
+    const mod = await loadOptionalPeer(
+      () => import("opendal"),
+      { feature: "Nextcloud resources", packageName: "opendal" }
+    );
+    const options = { endpoint: this.config.url };
+    if (this.config.username !== void 0) options.username = this.config.username;
+    if (this.config.password !== void 0) options.password = this.config.password;
+    return new mod.Operator("webdav", options);
+  }
+};
+
+// src/commands/builtin/nextcloud/index.ts
+import {
+  makeFiletypeCommands,
+  makeGenericCommands,
+  ResourceName as ResourceName5
+} from "@struktoai/mirage-core";
+
+// src/core/nextcloud/read.ts
+import {
+  enoent,
+  record,
+  ResourceName as ResourceName2
+} from "@struktoai/mirage-core";
+
+// src/core/nextcloud/util.ts
+import { lstripSlash, 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 nextcloudKey(path) {
+  return lstripSlash(rawPathOf(path));
+}
+function isNotFound(error) {
+  return error instanceof Error && error.message.startsWith("NotFound");
+}
+
+// src/core/nextcloud/read.ts
+async function read(accessor, path, _index, options = {}) {
+  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();
+  try {
+    const data = readOptions.offset !== void 0 || readOptions.size !== void 0 ? await op.read(nextcloudKey(path), readOptions) : await op.read(nextcloudKey(path));
+    const bytes = new Uint8Array(data);
+    record("read", path.virtual, ResourceName2.NEXTCLOUD, bytes.byteLength, startMs);
+    return bytes;
+  } catch (error) {
+    if (isNotFound(error)) throw enoent(path);
+    throw error;
+  }
+}
+
+// src/core/nextcloud/stat.ts
+import {
+  enoent as enoent2,
+  FileStat,
+  FileType,
+  guessType,
+  mountPrefixOf as mountPrefixOf2,
+  ResourceType,
+  stripSlash
+} from "@struktoai/mirage-core";
+async function stat(accessor, path, index) {
+  const prefix = mountPrefixOf2(path.virtual, path.resourcePath);
+  const raw = rawPathOf(path);
+  const key = stripSlash(raw);
+  if (key === "") return new FileStat({ name: "/", type: FileType.DIRECTORY });
+  const virtualKey = prefix !== "" ? `${prefix}/${key}` : `/${key}`;
+  if (index !== void 0) {
+    const lookup = await index.get(virtualKey);
+    if (lookup.entry !== void 0 && lookup.entry !== null) {
+      const entry = lookup.entry;
+      if (entry.resourceType === ResourceType.FOLDER) {
+        return new FileStat({
+          name: entry.name,
+          type: FileType.DIRECTORY,
+          modified: entry.remoteTime || null
+        });
+      }
+      return new FileStat({
+        name: entry.name,
+        size: entry.size ?? null,
+        modified: entry.remoteTime || null,
+        type: guessType(entry.name)
+      });
+    }
+    const parent = virtualKey.slice(0, virtualKey.lastIndexOf("/")) || "/";
+    const listing = await index.listDir(parent);
+    if (listing.entries !== void 0 && listing.entries !== null) throw enoent2(path);
+  }
+  const op = await accessor.operator();
+  let metadata = null;
+  try {
+    metadata = await op.stat(key);
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+  }
+  if (metadata !== null && !metadata.isDirectory()) return fileStat(key, raw, metadata);
+  try {
+    const directory = await op.stat(`${key}/`);
+    if (directory.isDirectory()) {
+      return new FileStat({
+        name: key.split("/").pop() ?? "/",
+        type: FileType.DIRECTORY,
+        modified: directory.lastModified
+      });
+    }
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+  }
+  throw enoent2(path);
+}
+function fileStat(key, raw, metadata) {
+  const etag = metadata.etag;
+  return new FileStat({
+    name: key.split("/").pop() ?? key,
+    size: metadata.contentLength !== null ? Number(metadata.contentLength) : null,
+    modified: metadata.lastModified,
+    type: guessType(raw),
+    fingerprint: etag,
+    extra: etag !== null && etag !== "" ? { etag } : {}
+  });
+}
+
+// src/core/nextcloud/constants.ts
+var SCOPE_ERROR = 5e3;
+var DEFAULT_CHUNK_SIZE = 8192;
+
+// src/core/nextcloud/copy.ts
+import { enoent as enoent3, invalidateAfterWrite } from "@struktoai/mirage-core";
+async function copy(accessor, source, destination) {
+  const op = await accessor.operator();
+  try {
+    await op.copy(nextcloudKey(source), nextcloudKey(destination));
+  } catch (error) {
+    if (isNotFound(error)) throw enoent3(source);
+    throw error;
+  }
+  await invalidateAfterWrite(destination);
+}
+
+// src/core/nextcloud/write.ts
+import {
+  enoent as enoent4,
+  invalidateAfterWrite as invalidateAfterWrite2,
+  record as record2,
+  ResourceName as ResourceName3
+} from "@struktoai/mirage-core";
+async function write(accessor, path, data, _index) {
+  const startMs = performance.now();
+  try {
+    const op = await accessor.operator();
+    await op.write(nextcloudKey(path), Buffer.from(data));
+  } catch (error) {
+    if (isNotFound(error)) throw enoent4(path);
+    throw error;
+  }
+  record2("write", path.virtual, ResourceName3.NEXTCLOUD, data.byteLength, startMs);
+  await invalidateAfterWrite2(path);
+}
+
+// src/core/nextcloud/create.ts
+function create(accessor, path, index) {
+  return write(accessor, path, new Uint8Array(), index);
+}
+
+// src/core/nextcloud/du.ts
+import {
+  FileType as FileType2,
+  lstripSlash as lstripSlash2,
+  stripSlash as stripSlash2
+} from "@struktoai/mirage-core";
+async function statOrNull(accessor, path) {
+  try {
+    return await stat(accessor, path);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function du(accessor, path) {
+  const info = await statOrNull(accessor, path);
+  if (info !== null && info.type !== FileType2.DIRECTORY) return info.size ?? 0;
+  const prefix = stripSlash2(rawPathOf(path));
+  const scanPath = prefix !== "" ? `${prefix}/` : "/";
+  const op = await accessor.operator();
+  let total = 0;
+  try {
+    for (const entry of await op.list(scanPath, { recursive: true })) {
+      const metadata = entry.metadata();
+      if (entry.path().endsWith("/") || metadata.isDirectory()) continue;
+      total += metadata.contentLength !== null ? Number(metadata.contentLength) : 0;
+    }
+  } catch (error) {
+    if (isNotFound(error)) return 0;
+    throw error;
+  }
+  return total;
+}
+async function duAll(accessor, path) {
+  const info = await statOrNull(accessor, path);
+  if (info !== null && info.type !== FileType2.DIRECTORY) return [[], info.size ?? 0];
+  const raw = rawPathOf(path);
+  const prefix = stripSlash2(raw);
+  const scanPath = prefix !== "" ? `${prefix}/` : "/";
+  const op = await accessor.operator();
+  const entries = [];
+  let total = 0;
+  try {
+    for (const entry of await op.list(scanPath, { recursive: true })) {
+      const key = entry.path();
+      const metadata = entry.metadata();
+      if (key === "" || key.endsWith("/") || metadata.isDirectory()) continue;
+      const size = metadata.contentLength !== null ? Number(metadata.contentLength) : 0;
+      entries.push([`/${lstripSlash2(key)}`, size]);
+      total += size;
+    }
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+  }
+  entries.sort(([left], [right]) => left.localeCompare(right));
+  return [entries, total];
+}
+
+// src/core/nextcloud/exists.ts
+async function exists(accessor, path) {
+  try {
+    await stat(accessor, path);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+// src/core/nextcloud/find.ts
+import {
+  keep,
+  optionsTree,
+  rstripSlash as rstripSlash3,
+  startBasename,
+  stripSlash as stripSlash4,
+  treeHasEmpty
+} from "@struktoai/mirage-core";
+
+// src/core/nextcloud/search/types.ts
+var Namespace = {
+  DAV: "DAV:",
+  OWNCLOUD: "http://owncloud.org/ns",
+  SEARCHDAV: "https://github.com/icewind1991/SearchDAV/ns"
+};
+var Comparison = {
+  EQUAL: "eq",
+  GREATER_THAN_OR_EQUAL: "gte",
+  LESS_THAN_OR_EQUAL: "lte",
+  LIKE: "like"
+};
+var BooleanOperation = {
+  AND: "and",
+  OR: "or"
+};
+
+// src/core/nextcloud/search/constants.ts
+var DISPLAY_NAME = {
+  namespace: Namespace.DAV,
+  prefix: "d",
+  name: "displayname"
+};
+var RESOURCE_TYPE = {
+  namespace: Namespace.DAV,
+  prefix: "d",
+  name: "resourcetype"
+};
+var CONTENT_LENGTH = {
+  namespace: Namespace.DAV,
+  prefix: "d",
+  name: "getcontentlength"
+};
+var LAST_MODIFIED = {
+  namespace: Namespace.DAV,
+  prefix: "d",
+  name: "getlastmodified"
+};
+var SIZE = {
+  namespace: Namespace.OWNCLOUD,
+  prefix: "oc",
+  name: "size"
+};
+var SELECT_PROPERTIES = [DISPLAY_NAME, RESOURCE_TYPE, CONTENT_LENGTH, LAST_MODIFIED, SIZE];
+var ORDER_PROPERTIES = [DISPLAY_NAME, LAST_MODIFIED, SIZE];
+var SEARCH_METHOD = "SEARCH";
+var SEARCH_ENDPOINT_PATH = "/remote.php/dav/";
+var SEARCH_DEPTH = "infinity";
+var SEARCH_PAGE_SIZE = 100;
+var SEARCH_HEADERS = {
+  Accept: "application/xml",
+  "Content-Type": "text/xml; charset=utf-8"
+};
+var UNAVAILABLE_STATUS_CODES = /* @__PURE__ */ new Set([404, 405, 501]);
+
+// src/core/nextcloud/search/target.ts
+import { rstripSlash, stripSlash as stripSlash3 } from "@struktoai/mirage-core";
+function decodePath(path) {
+  try {
+    return decodeURIComponent(path);
+  } catch (error) {
+    throw new Error(`invalid percent-encoding in Nextcloud path: ${path}`, { cause: error });
+  }
+}
+function searchTarget(url) {
+  const parsed = new URL(url);
+  const marker = parsed.pathname.indexOf(SEARCH_ENDPOINT_PATH);
+  if (marker < 0) return null;
+  const davEnd = marker + SEARCH_ENDPOINT_PATH.length;
+  const relative = stripSlash3(parsed.pathname.slice(davEnd));
+  const parts = relative === "" ? [] : relative.split("/");
+  if (parts.length < 2 || parts[0] !== "files") return null;
+  const endpoint = new URL(parsed.toString());
+  endpoint.pathname = parsed.pathname.slice(0, davEnd);
+  endpoint.search = "";
+  endpoint.hash = "";
+  return {
+    endpoint: endpoint.toString(),
+    resourceScope: decodePath(`/${parts.join("/")}`)
+  };
+}
+function scopePath(target, path) {
+  const relative = stripSlash3(rawPathOf(path));
+  return relative === "" ? target.resourceScope : `${rstripSlash(target.resourceScope)}/${relative}`;
+}
+function stripScope(path, scope) {
+  if (path === scope) return "";
+  const prefix = `${rstripSlash(scope)}/`;
+  return path.startsWith(prefix) ? path.slice(prefix.length) : null;
+}
+function relativePath(href, target) {
+  const hrefPath = rstripSlash(decodePath(new URL(href, target.endpoint).pathname));
+  const resourceScope = rstripSlash(target.resourceScope);
+  let relative = stripScope(hrefPath, resourceScope);
+  if (relative === null) {
+    const davRoot = rstripSlash(decodePath(new URL(target.endpoint).pathname));
+    relative = stripScope(hrefPath, `${davRoot}${resourceScope}`);
+  }
+  if (relative === null) {
+    throw new Error(`Nextcloud Files Search returned an out-of-scope href: ${href}`);
+  }
+  return relative !== "" ? `/${relative}` : "/";
+}
+
+// src/core/nextcloud/search/query.ts
+function escapeXml(value) {
+  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function propertyTag(field) {
+  return `<${field.prefix}:${field.name}/>`;
+}
+function property(field) {
+  return `<d:prop>${propertyTag(field)}</d:prop>`;
+}
+function comparison(operation, field, value) {
+  return `<d:${operation}>${property(field)}<d:literal>${escapeXml(value)}</d:literal></d:${operation}>`;
+}
+function isCollection() {
+  return "<d:is-collection/>";
+}
+function negate(condition) {
+  return `<d:not>${condition}</d:not>`;
+}
+function combine(operation, conditions) {
+  const [only] = conditions;
+  if (only !== void 0 && conditions.length === 1) return only;
+  return `<d:${operation}>${conditions.join("")}</d:${operation}>`;
+}
+function globToLike(pattern) {
+  let translated = "";
+  for (const character of pattern) {
+    if (character === "*") translated += "%";
+    else if (character === "?") translated += "_";
+    else if (character === "\\") translated += "%";
+    else translated += character;
+  }
+  return translated;
+}
+function nameCondition(node) {
+  const wildcard = node.pattern.includes("*") || node.pattern.includes("?");
+  const operation = wildcard || node.icase ? Comparison.LIKE : Comparison.EQUAL;
+  const value = operation === Comparison.LIKE ? globToLike(node.pattern) : node.pattern;
+  return comparison(operation, DISPLAY_NAME, value);
+}
+function compilePredicate(node) {
+  switch (node.op) {
+    case "true":
+      return { condition: null };
+    case "name":
+      return node.pattern.includes("[") ? null : { condition: nameCondition(node) };
+    case "type":
+      if (node.kind === "d") return { condition: isCollection() };
+      if (node.kind === "f") return { condition: negate(isCollection()) };
+      return null;
+    case "not": {
+      const compiled = compilePredicate(node.kid);
+      return compiled?.condition != null ? { condition: negate(compiled.condition) } : null;
+    }
+    case "and":
+    case "or": {
+      const conditions = [];
+      for (const kid of node.kids) {
+        const compiled = compilePredicate(kid);
+        if (compiled === null) return null;
+        if (compiled.condition === null) {
+          if (node.op === "or") return null;
+          continue;
+        }
+        conditions.push(compiled.condition);
+      }
+      if (conditions.length === 0) return node.op === "and" ? { condition: null } : null;
+      const operation = node.op === "and" ? BooleanOperation.AND : BooleanOperation.OR;
+      return { condition: combine(operation, conditions) };
+    }
+    case "path":
+    case "empty":
+      return null;
+  }
+}
+function sizeCondition(query) {
+  const size = query.size;
+  if (size === void 0) return null;
+  const conditions = [];
+  if (size.lower !== null && size.lower === size.upper) {
+    conditions.push(comparison(Comparison.EQUAL, SIZE, size.lower));
+  } else {
+    if (size.lower !== null) {
+      conditions.push(comparison(Comparison.GREATER_THAN_OR_EQUAL, SIZE, size.lower));
+    }
+    if (size.upper !== null) {
+      conditions.push(comparison(Comparison.LESS_THAN_OR_EQUAL, SIZE, size.upper));
+    }
+  }
+  if (conditions.length === 0) return null;
+  const fileBounds = combine(BooleanOperation.AND, [negate(isCollection()), ...conditions]);
+  const includesZero = (size.lower === null || size.lower <= 0) && (size.upper === null || size.upper >= 0);
+  return includesZero ? combine(BooleanOperation.OR, [isCollection(), fileBounds]) : fileBounds;
+}
+function whereCondition(query) {
+  const compiled = compilePredicate(query.tree);
+  if (compiled === null) return null;
+  const conditions = [];
+  if (compiled.condition !== null) conditions.push(compiled.condition);
+  const size = sizeCondition(query);
+  if (size !== null) conditions.push(size);
+  if (query.modified?.lower != null) {
+    conditions.push(
+      comparison(Comparison.GREATER_THAN_OR_EQUAL, LAST_MODIFIED, Math.floor(query.modified.lower))
+    );
+  }
+  if (query.modified?.upper != null) {
+    conditions.push(
+      comparison(Comparison.LESS_THAN_OR_EQUAL, LAST_MODIFIED, Math.ceil(query.modified.upper))
+    );
+  }
+  return conditions.length > 0 ? combine(BooleanOperation.AND, conditions) : null;
+}
+function supportsQuery(query) {
+  return whereCondition(query) !== null;
+}
+function order(field) {
+  return `<d:order>${property(field)}<d:ascending/></d:order>`;
+}
+function requestBody(target, path, query, offset) {
+  const condition = whereCondition(query);
+  if (condition === null) throw new Error("Nextcloud Files Search requires a supported query");
+  const selected = SELECT_PROPERTIES.map(propertyTag).join("");
+  const ordered = ORDER_PROPERTIES.map(order).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><d:searchrequest xmlns:d="${Namespace.DAV}" xmlns:oc="${Namespace.OWNCLOUD}" xmlns:sd="${Namespace.SEARCHDAV}"><d:basicsearch><d:select><d:prop>${selected}</d:prop></d:select><d:from><d:scope><d:href>${escapeXml(scopePath(target, path))}</d:href><d:depth>${SEARCH_DEPTH}</d:depth></d:scope></d:from><d:where>${condition}</d:where><d:orderby>${ordered}</d:orderby><d:limit><d:nresults>${String(SEARCH_PAGE_SIZE)}</d:nresults><sd:firstresult>${String(offset)}</sd:firstresult></d:limit></d:basicsearch></d:searchrequest>`;
+}
+
+// src/core/nextcloud/search/response.ts
+import { XMLParser } from "fast-xml-parser";
+import { SyntaxValidator } from "fast-xml-validator";
+import { rstripSlash as rstripSlash2 } from "@struktoai/mirage-core";
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  removeNSPrefix: true,
+  parseTagValue: false,
+  trimValues: false
+});
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function records(value) {
+  if (Array.isArray(value)) return value.filter(isRecord);
+  return isRecord(value) ? [value] : [];
+}
+function stringValue(value) {
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  return null;
+}
+function successfulProperties(response) {
+  const properties = [];
+  for (const propstat of records(response.propstat)) {
+    const status = stringValue(propstat.status) ?? "";
+    const fields = status.split(/\s+/);
+    if (fields[1] === "200" && isRecord(propstat.prop)) properties.push(propstat.prop);
+  }
+  if (properties.length === 0) {
+    throw new Error("Nextcloud Files Search result has no successful properties");
+  }
+  return properties;
+}
+function findText(properties, field) {
+  for (const propertySet of properties) {
+    const value = stringValue(propertySet[field.name]);
+    if (value !== null) return value;
+  }
+  return null;
+}
+function hasCollection(properties) {
+  return properties.some((propertySet) => {
+    const resourceType = propertySet[RESOURCE_TYPE.name];
+    return isRecord(resourceType) && "collection" in resourceType;
+  });
+}
+function modifiedTimestamp(value) {
+  if (value === null) return null;
+  const milliseconds = Date.parse(value);
+  if (Number.isNaN(milliseconds)) {
+    throw new Error(`invalid Nextcloud Files Search timestamp: ${value}`);
+  }
+  return milliseconds / 1e3;
+}
+function entrySize(properties) {
+  const value = findText(properties, SIZE) ?? findText(properties, CONTENT_LENGTH);
+  if (value === null) return null;
+  const size = Number(value);
+  if (!Number.isInteger(size)) throw new Error(`invalid Nextcloud Files Search size: ${value}`);
+  return size;
+}
+function parseResponse(response, target) {
+  const href = stringValue(response.href);
+  if (href === null) throw new Error("Nextcloud Files Search result is missing href");
+  const properties = successfulProperties(response);
+  const key = relativePath(href, target);
+  return {
+    key,
+    name: findText(properties, DISPLAY_NAME) ?? rstripSlash2(key).split("/").pop() ?? "",
+    kind: hasCollection(properties) ? "d" : "f",
+    size: entrySize(properties),
+    modified: modifiedTimestamp(findText(properties, LAST_MODIFIED))
+  };
+}
+function validateXml(content) {
+  try {
+    const validation = SyntaxValidator.validate(content);
+    if (validation !== true) throw new Error(validation.err.msg);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`invalid Nextcloud Files Search XML: ${message}`, { cause: error });
+  }
+}
+function parsePage(content, target) {
+  validateXml(content);
+  const parsed = parser.parse(content);
+  if (!isRecord(parsed) || !("multistatus" in parsed)) {
+    throw new Error("invalid Nextcloud Files Search response");
+  }
+  const multistatus = parsed.multistatus;
+  if (multistatus === "") return [];
+  if (!isRecord(multistatus)) throw new Error("invalid Nextcloud Files Search response");
+  return records(multistatus.response).map((response) => parseResponse(response, target));
+}
+
+// src/core/nextcloud/search/client.ts
+function authorization(accessor) {
+  const username = accessor.config.username;
+  if (username === void 0 || username === "") return null;
+  return `Basic ${Buffer.from(`${username}:${accessor.config.password ?? ""}`).toString("base64")}`;
+}
+async function searchFiles(accessor, path, query) {
+  if (!supportsQuery(query)) return null;
+  const target = searchTarget(accessor.config.url);
+  if (target === null) return null;
+  const headers = { ...SEARCH_HEADERS };
+  const auth = authorization(accessor);
+  if (auth !== null) headers.Authorization = auth;
+  const entries = /* @__PURE__ */ new Map();
+  let offset = 0;
+  for (; ; ) {
+    const response = await fetch(target.endpoint, {
+      method: SEARCH_METHOD,
+      headers,
+      body: requestBody(target, path, query, offset),
+      signal: AbortSignal.timeout((accessor.config.timeout ?? 30) * 1e3)
+    });
+    if (UNAVAILABLE_STATUS_CODES.has(response.status)) return null;
+    if (!response.ok) {
+      throw new Error(`Nextcloud Files Search returned HTTP ${String(response.status)}`);
+    }
+    if (response.status !== 207) {
+      throw new Error(
+        `Nextcloud Files Search returned HTTP ${String(response.status)}, expected 207`
+      );
+    }
+    const page = parsePage(await response.text(), target);
+    const previousSize = entries.size;
+    for (const entry of page) if (!entries.has(entry.key)) entries.set(entry.key, entry);
+    if (page.length > 0 && entries.size === previousSize) return null;
+    if (page.length < SEARCH_PAGE_SIZE) break;
+    offset += page.length;
+  }
+  return [...entries.values()];
+}
+
+// src/core/nextcloud/find.ts
+function findScope(path) {
+  const relative = stripSlash4(rawPathOf(path));
+  return {
+    baseKey: relative !== "" ? `/${relative}` : "/",
+    scanKey: relative !== "" ? `${relative}/` : "/",
+    startName: startBasename(path.virtual)
+  };
+}
+function constrained(bounds) {
+  return bounds.lower !== null || bounds.upper !== null;
+}
+function contains(bounds, value) {
+  if (bounds.lower !== null && value < bounds.lower) return false;
+  if (bounds.upper !== null && value > bounds.upper) return false;
+  return true;
+}
+function scopeContains(scope, key) {
+  if (scope.baseKey === "/") return key.startsWith("/");
+  return key === scope.baseKey || key.startsWith(`${scope.baseKey}/`);
+}
+function depth(scope, key) {
+  if (key === scope.baseKey) return 0;
+  const baseDepth = scope.baseKey === "/" ? 0 : (scope.baseKey.match(/\//g) ?? []).length;
+  return (key.match(/\//g) ?? []).length - baseDepth;
+}
+function parentKeys(scope, key) {
+  const keys = [];
+  let parent = key.slice(0, key.lastIndexOf("/")) || "/";
+  while (scopeContains(scope, parent)) {
+    keys.push(parent);
+    if (parent === scope.baseKey) break;
+    parent = parent.slice(0, parent.lastIndexOf("/")) || "/";
+  }
+  return keys;
+}
+function basename(key) {
+  return rstripSlash3(key).split("/").pop() ?? "";
+}
+function modifiedTimestamp2(metadata) {
+  if (metadata.lastModified === null) return null;
+  const milliseconds = Date.parse(metadata.lastModified);
+  return Number.isNaN(milliseconds) ? null : milliseconds / 1e3;
+}
+function candidateFromMetadata(key, name, metadata) {
+  const isDirectory = metadata.isDirectory();
+  return {
+    key,
+    name,
+    kind: isDirectory ? "d" : "f",
+    size: isDirectory ? 0 : metadata.contentLength !== null ? Number(metadata.contentLength) : null,
+    modified: modifiedTimestamp2(metadata),
+    isEmpty: null
+  };
+}
+function candidateFromSearch(entry) {
+  return { ...entry, isEmpty: null };
+}
+async function statCandidate(accessor, key, name) {
+  if (key === "/") {
+    return { key, name, kind: "d", size: 0, modified: null, isEmpty: null };
+  }
+  const op = await accessor.operator();
+  const relative = stripSlash4(key);
+  let metadata;
+  try {
+    metadata = await op.stat(relative);
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+    try {
+      metadata = await op.stat(`${relative}/`);
+    } catch (directoryError) {
+      if (isNotFound(directoryError)) return null;
+      throw directoryError;
+    }
+  }
+  return candidateFromMetadata(key, name, metadata);
+}
+function matches(candidate, scope, criteria) {
+  if (!scopeContains(scope, candidate.key)) {
+    throw new Error(`Nextcloud Files Search returned an out-of-scope path: ${candidate.key}`);
+  }
+  const candidateDepth = depth(scope, candidate.key);
+  if (criteria.maxDepth !== null && candidateDepth > criteria.maxDepth) return false;
+  const entry = {
+    key: candidate.key,
+    name: candidate.name,
+    kind: candidate.kind,
+    depth: candidateDepth,
+    isEmpty: candidate.isEmpty
+  };
+  if (!keep(entry, criteria.predicate, criteria.minDepth)) return false;
+  if (constrained(criteria.size)) {
+    const size = candidate.kind === "d" ? 0 : candidate.size ?? 0;
+    if (!contains(criteria.size, size)) return false;
+  }
+  if (constrained(criteria.modified)) {
+    if (candidate.modified === null || !contains(criteria.modified, candidate.modified))
+      return false;
+  }
+  return true;
+}
+function matchingKeys(candidates, scope, criteria) {
+  return [...candidates.values()].filter((candidate) => matches(candidate, scope, criteria)).map((candidate) => candidate.key).sort();
+}
+function searchQuery(criteria) {
+  return {
+    tree: criteria.predicate,
+    size: criteria.size,
+    modified: criteria.modified
+  };
+}
+async function findWithSearch(accessor, path, scope, criteria) {
+  if (criteria.maxDepth === 0 && !treeHasEmpty(criteria.predicate)) {
+    const start2 = await statCandidate(accessor, scope.baseKey, scope.startName);
+    if (start2 === null) return [];
+    return matchingKeys(/* @__PURE__ */ new Map([[scope.baseKey, start2]]), scope, criteria);
+  }
+  const query = searchQuery(criteria);
+  if (!supportsQuery(query)) return null;
+  const start = await statCandidate(accessor, scope.baseKey, scope.startName);
+  if (start === null) return [];
+  if (start.kind !== "d") return null;
+  const candidates = /* @__PURE__ */ new Map([[scope.baseKey, start]]);
+  if (criteria.maxDepth !== 0) {
+    const found = await searchFiles(accessor, path, query);
+    if (found === null) return null;
+    for (const entry of found) {
+      if (!candidates.has(entry.key)) candidates.set(entry.key, candidateFromSearch(entry));
+    }
+  }
+  return matchingKeys(candidates, scope, criteria);
+}
+function scanKey(rawKey) {
+  return `/${stripSlash4(rawKey)}`;
+}
+function directoryCandidate(key) {
+  return { key, name: basename(key), kind: "d", size: 0, modified: null, isEmpty: null };
+}
+async function collectScanCandidates(accessor, scope) {
+  const candidates = /* @__PURE__ */ new Map();
+  const nonemptyDirectories = /* @__PURE__ */ new Set();
+  const op = await accessor.operator();
+  let entries;
+  try {
+    entries = await op.list(scope.scanKey, { recursive: true });
+  } catch (error) {
+    if (isNotFound(error)) return { candidates, nonemptyDirectories };
+    throw error;
+  }
+  for (const entry of entries) {
+    const rawKey = entry.path();
+    if (rawKey === "") continue;
+    const key = scanKey(rawKey);
+    candidates.set(key, candidateFromMetadata(key, basename(key), entry.metadata()));
+    for (const parent of parentKeys(scope, key)) {
+      nonemptyDirectories.add(parent);
+      if (!candidates.has(parent)) candidates.set(parent, directoryCandidate(parent));
+    }
+  }
+  return { candidates, nonemptyDirectories };
+}
+function emptyState(candidate, nonemptyDirectories) {
+  return candidate.kind === "d" ? !nonemptyDirectories.has(candidate.key) : (candidate.size ?? 0) === 0;
+}
+async function hydrateScanCandidate(accessor, candidate, nonemptyDirectories, criteria) {
+  let hydrated = candidate;
+  if (constrained(criteria.modified) && candidate.kind === "d" && candidate.modified === null) {
+    hydrated = await statCandidate(accessor, candidate.key, candidate.name) ?? candidate;
+  }
+  return { ...hydrated, isEmpty: emptyState(hydrated, nonemptyDirectories) };
+}
+async function findWithScan(accessor, scope, criteria) {
+  const { candidates, nonemptyDirectories } = await collectScanCandidates(accessor, scope);
+  const start = await statCandidate(accessor, scope.baseKey, scope.startName);
+  if (start === null) return [];
+  candidates.set(scope.baseKey, start);
+  const hydrated = /* @__PURE__ */ new Map();
+  for (const candidate of candidates.values()) {
+    const entry = await hydrateScanCandidate(accessor, candidate, nonemptyDirectories, criteria);
+    hydrated.set(entry.key, entry);
+  }
+  return matchingKeys(hydrated, scope, criteria);
+}
+async function find(accessor, path, options = {}) {
+  const scope = findScope(path);
+  const criteria = {
+    predicate: optionsTree(options),
+    size: { lower: options.minSize ?? null, upper: options.maxSize ?? null },
+    modified: { lower: options.mtimeMin ?? null, upper: options.mtimeMax ?? null },
+    minDepth: options.minDepth ?? null,
+    maxDepth: options.maxDepth ?? null
+  };
+  const searchResults = await findWithSearch(accessor, path, scope, criteria);
+  return searchResults ?? findWithScan(accessor, scope, criteria);
+}
+
+// src/core/nextcloud/mkdir.ts
+import {
+  invalidateAfterWrite as invalidateAfterWrite3,
+  invalidateAncestors,
+  rstripSlash as rstripSlash4
+} from "@struktoai/mirage-core";
+async function mkdir(accessor, path, parents = false) {
+  const key = `${rstripSlash4(nextcloudKey(path))}/`;
+  const op = await accessor.operator();
+  await op.createDir(key);
+  await invalidateAfterWrite3(path);
+  if (parents) await invalidateAncestors(path);
+}
+
+// src/core/nextcloud/readdir.ts
+import {
+  enotdir,
+  enoent as enoent5,
+  IndexEntry,
+  mountPrefixOf as mountPrefixOf3,
+  ResourceType as ResourceType2,
+  rstripSlash as rstripSlash5,
+  stripSlash as stripSlash5
+} from "@struktoai/mirage-core";
+async function readdir(accessor, path, index) {
+  const prefix = mountPrefixOf3(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 = rstripSlash5(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 stripped = stripSlash5(target);
+  const listPath = stripped !== "" ? `${stripped}/` : "/";
+  const op = await accessor.operator();
+  let entries;
+  try {
+    entries = await op.list(listPath);
+  } catch (error) {
+    if (isNotFound(error)) throw enoent5(path);
+    throw error;
+  }
+  const names = [];
+  const directories = /* @__PURE__ */ new Set();
+  const metadata = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const relative = entry.path();
+    if (relative === "" || relative === listPath) continue;
+    const info = entry.metadata();
+    const isDirectory = relative.endsWith("/") || info.isDirectory();
+    const key = `/${rstripSlash5(relative)}`;
+    names.push(key);
+    if (isDirectory) directories.add(key);
+    metadata.set(key, {
+      size: info.contentLength !== null ? Number(info.contentLength) : null,
+      modified: info.lastModified ?? ""
+    });
+  }
+  const targetKey = `/${stripSlash5(target)}`;
+  if (names.length === 1 && names[0] === targetKey && !directories.has(targetKey)) {
+    throw enotdir(path);
+  }
+  names.sort();
+  if (names.length > SCOPE_ERROR) {
+    console.warn(
+      `nextcloud readdir: ${virtualKey} returned ${String(names.length)} entries (limit ${String(SCOPE_ERROR)})`
+    );
+  }
+  if (index !== void 0) {
+    await index.setDir(
+      virtualKey,
+      names.map((key) => {
+        const name = key.split("/").pop() ?? key;
+        const info = metadata.get(key);
+        return [
+          name,
+          new IndexEntry({
+            id: key,
+            name,
+            resourceType: directories.has(key) ? ResourceType2.FOLDER : ResourceType2.FILE,
+            size: directories.has(key) ? null : info?.size ?? null,
+            remoteTime: info?.modified ?? ""
+          })
+        ];
+      })
+    );
+  }
+  return names.map((key) => prefix !== "" ? `${prefix}${key}` : key).sort();
+}
+
+// src/core/nextcloud/rename.ts
+import {
+  enoent as enoent6,
+  invalidateAfterUnlink,
+  invalidateAfterWrite as invalidateAfterWrite4
+} from "@struktoai/mirage-core";
+async function rename(accessor, source, destination) {
+  const op = await accessor.operator();
+  try {
+    await op.rename(nextcloudKey(source), nextcloudKey(destination));
+  } catch (error) {
+    if (isNotFound(error)) throw enoent6(source);
+    throw error;
+  }
+  await invalidateAfterWrite4(destination);
+  await invalidateAfterUnlink(source);
+}
+
+// src/core/nextcloud/rm.ts
+import { enoent as enoent7, invalidateAfterUnlink as invalidateAfterUnlink2, rstripSlash as rstripSlash6 } from "@struktoai/mirage-core";
+async function rmR(accessor, path) {
+  const key = `${rstripSlash6(nextcloudKey(path))}/`;
+  const op = await accessor.operator();
+  try {
+    await op.removeAll(key);
+  } catch (error) {
+    if (isNotFound(error)) throw enoent7(path);
+    throw error;
+  }
+  await invalidateAfterUnlink2(path);
+}
+
+// src/core/nextcloud/rmdir.ts
+import { enoent as enoent8, invalidateAfterUnlink as invalidateAfterUnlink3, rstripSlash as rstripSlash7 } from "@struktoai/mirage-core";
+async function rmdir(accessor, path) {
+  const key = `${rstripSlash7(nextcloudKey(path))}/`;
+  const op = await accessor.operator();
+  try {
+    await op.delete(key);
+  } catch (error) {
+    if (isNotFound(error)) throw enoent8(path);
+    throw error;
+  }
+  await invalidateAfterUnlink3(path);
+}
+
+// src/core/nextcloud/stream.ts
+import { enoent as enoent9, recordStream } from "@struktoai/mirage-core";
+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 op = await accessor.operator();
+  const rec = recordStream("read", path.virtual, accessor.resourceName);
+  let reader;
+  try {
+    reader = await op.reader(nextcloudKey(path));
+  } catch (error) {
+    if (isNotFound(error)) throw enoent9(path);
+    throw error;
+  }
+  const buffer = Buffer.alloc(chunkSize);
+  for (; ; ) {
+    const size = Number(await reader.read(buffer));
+    if (size <= 0) break;
+    const chunk = new Uint8Array(buffer.subarray(0, size));
+    if (rec !== null) rec.bytes += chunk.byteLength;
+    yield chunk;
+  }
+}
+
+// src/core/nextcloud/truncate.ts
+import { invalidateAfterWrite as invalidateAfterWrite5 } from "@struktoai/mirage-core";
+async function truncate(accessor, path, length) {
+  const op = await accessor.operator();
+  const key = nextcloudKey(path);
+  let current;
+  try {
+    current = await op.read(key);
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+    current = Buffer.alloc(0);
+  }
+  const next = Buffer.alloc(length);
+  current.copy(next, 0, 0, Math.min(current.byteLength, length));
+  await op.write(key, next);
+  await invalidateAfterWrite5(path);
+}
+
+// src/core/nextcloud/unlink.ts
+import {
+  enoent as enoent10,
+  invalidateAfterUnlink as invalidateAfterUnlink4,
+  record as record3,
+  ResourceName as ResourceName4
+} from "@struktoai/mirage-core";
+async function unlink(accessor, path) {
+  const op = await accessor.operator();
+  const startMs = performance.now();
+  try {
+    await op.delete(nextcloudKey(path));
+  } catch (error) {
+    if (isNotFound(error)) throw enoent10(path);
+    throw error;
+  }
+  record3("unlink", path.virtual, ResourceName4.NEXTCLOUD, 0, startMs);
+  await invalidateAfterUnlink4(path);
+}
+
+// src/commands/builtin/nextcloud/io.ts
+var NEXTCLOUD_IO = {
+  maxGlobMatches: SCOPE_ERROR,
+  readdir,
+  readBytes: read,
+  readStream: stream,
+  stat,
+  isMounted: () => true,
+  local: false,
+  write,
+  exists,
+  mkdir,
+  unlink,
+  rmdir,
+  rmR,
+  rename,
+  copy,
+  create,
+  truncate,
+  find,
+  duTotal: du,
+  duAll
+};
+
+// src/commands/builtin/nextcloud/index.ts
+var NEXTCLOUD_COMMANDS = [
+  ...makeFiletypeCommands({
+    resource: ResourceName5.NEXTCLOUD,
+    readBytes: read,
+    statEntry: stat
+  }),
+  ...makeGenericCommands(ResourceName5.NEXTCLOUD, NEXTCLOUD_IO)
+];
+
+// src/ops/nextcloud/index.ts
+import { makeGenericOps, ResourceName as ResourceName6 } from "@struktoai/mirage-core";
+var NEXTCLOUD_OPS = makeGenericOps(
+  ResourceName6.NEXTCLOUD,
+  NEXTCLOUD_IO,
+  { filetypeRead: [".feather", ".hdf5", ".parquet"] }
+);
+
+// src/resource/nextcloud/prompt.ts
+var NEXTCLOUD_PROMPT = "You have access to files stored in Nextcloud.";
+
+// src/resource/nextcloud/nextcloud.ts
+var resolveGlobCore = makeResolveGlob(readdir, SCOPE_ERROR);
+var NextcloudResource = class extends BaseResource {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.accessor = new NextcloudAccessor(config);
+  }
+  config;
+  kind = ResourceName7.NEXTCLOUD;
+  cachesReads = true;
+  supportsSnapshot = true;
+  prompt = NEXTCLOUD_PROMPT;
+  accessor;
+  opsMap = {
+    read_bytes: read,
+    write,
+    readdir,
+    stat,
+    unlink,
+    rmdir,
+    copy,
+    rename,
+    mkdir,
+    read_stream: stream,
+    range_read: rangeRead,
+    rm_recursive: rmR,
+    du_total: du,
+    du_all: duAll,
+    create,
+    truncate,
+    exists,
+    find_flat: find
+  };
+  open() {
+    return Promise.resolve();
+  }
+  close() {
+    return Promise.resolve();
+  }
+  commands() {
+    return NEXTCLOUD_COMMANDS;
+  }
+  ops() {
+    return NEXTCLOUD_OPS;
+  }
+  streamPath(path) {
+    return stream(this.accessor, path, this.index);
+  }
+  readFile(path) {
+    return read(this.accessor, path, this.index);
+  }
+  writeFile(path, data) {
+    return write(this.accessor, path, data, this.index);
+  }
+  async appendFile(path, data) {
+    let existing;
+    try {
+      existing = await read(this.accessor, path, this.index);
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+      existing = new Uint8Array();
+    }
+    const merged = new Uint8Array(existing.byteLength + data.byteLength);
+    merged.set(existing);
+    merged.set(data, existing.byteLength);
+    await write(this.accessor, path, merged, this.index);
+  }
+  readdir(path) {
+    return readdir(this.accessor, path, this.index);
+  }
+  stat(path) {
+    return stat(this.accessor, path, this.index);
+  }
+  exists(path) {
+    return exists(this.accessor, path);
+  }
+  mkdir(path) {
+    return mkdir(this.accessor, path);
+  }
+  rmdir(path) {
+    return rmdir(this.accessor, path);
+  }
+  unlink(path) {
+    return unlink(this.accessor, path);
+  }
+  rename(source, destination) {
+    return rename(this.accessor, source, destination);
+  }
+  truncate(path, length) {
+    return truncate(this.accessor, path, length);
+  }
+  copy(source, destination) {
+    return copy(this.accessor, source, destination);
+  }
+  rmR(path) {
+    return rmR(this.accessor, path);
+  }
+  du(path) {
+    return du(this.accessor, path);
+  }
+  find(path, options = {}) {
+    return find(this.accessor, path, options);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix ? paths.map(
+      (path) => mountPrefixOf4(path.virtual, path.resourcePath) ? path : new PathSpec({
+        virtual: path.virtual,
+        directory: path.directory,
+        ...path.pattern !== null ? { pattern: path.pattern } : {},
+        resolved: path.resolved,
+        resourcePath: mountKey(path.virtual, prefix)
+      })
+    ) : paths;
+    return resolveGlobCore(this.accessor, effective, this.index);
+  }
+  getState() {
+    return Promise.resolve({ type: this.kind, config: redactNextcloudConfig(this.config) });
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  NextcloudAccessor,
+  NEXTCLOUD_COMMANDS,
+  NEXTCLOUD_OPS,
+  NEXTCLOUD_PROMPT,
+  NextcloudResource
+};
+//# sourceMappingURL=chunk-ZPZQXHW2.js.map