@yaklabs-ai/plugin-sdk 0.12.5 → 0.13.1

package/dist/fs.js

@@ -0,0 +1,895 @@
+// packages/plugin-sdk/dist/fs/index.js
+import { Buffer as Buffer3 } from "node:buffer";
+import { constants } from "node:fs";
+import * as nodeFsp from "node:fs/promises";
+import { basename, dirname, join, resolve as resolve2 } from "node:path";
+
+// packages/plugin-sdk/dist/fs/handle.js
+import { Buffer as Buffer2 } from "node:buffer";
+import { EventEmitter } from "node:events";
+import { createInterface } from "node:readline";
+import { Readable, Writable } from "node:stream";
+
+// packages/plugin-sdk/dist/fs/internal.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Buffer } from "node:buffer";
+import { Dirent, Stats } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var KAY_FS_DEFAULT_TIMEOUT_MS = 3e4;
+var KAY_FS_DEADLINE = "ERR_KAY_FS_DEADLINE";
+var KAY_FS_COOLING_DOWN = "ERR_KAY_FS_COOLING_DOWN";
+var KAY_FS_SATURATED = "ERR_KAY_FS_SATURATED";
+var KAY_FS_UNAVAILABLE = "ERR_KAY_FS_UNAVAILABLE";
+var KAY_FS_UNSUPPORTED = "ERR_KAY_FS_UNSUPPORTED";
+var FINISHED = Symbol("kay.fs.finished");
+function wirePath(path) {
+  if (path instanceof URL)
+    return fileURLToPath(path);
+  if (typeof path === "string" || Buffer.isBuffer(path))
+    return path;
+  if (path instanceof Uint8Array)
+    return Buffer.from(path);
+  throw Object.assign(new TypeError(`The "path" argument must be of type string or an instance of Buffer or URL. Received ${describeArg(path)}`), { code: "ERR_INVALID_ARG_TYPE" });
+}
+function describeArg(value) {
+  if (value === null || value === void 0)
+    return String(value);
+  if (typeof value === "function")
+    return `function ${value.name}`;
+  if (typeof value === "object") {
+    const name = value.constructor?.name;
+    return name === void 0 ? "an object" : `an instance of ${name}`;
+  }
+  const primitive = value;
+  return `type ${typeof value} (${String(primitive)})`;
+}
+function keyPath(path) {
+  const wire = wirePath(path);
+  return resolve(typeof wire === "string" ? wire : wire.toString());
+}
+function isOptionsObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function callOptionsOf(options) {
+  return isOptionsObject(options) ? options : void 0;
+}
+var scopedTimeout = new AsyncLocalStorage();
+function withTimeout(timeoutMs, run) {
+  return scopedTimeout.run(timeoutMs, run);
+}
+var positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
+function timeoutOf(options) {
+  const own = callOptionsOf(options)?.timeoutMs;
+  if (positive(own))
+    return own;
+  const scoped = scopedTimeout.getStore();
+  return positive(scoped) ? scoped : KAY_FS_DEFAULT_TIMEOUT_MS;
+}
+function signalOf(options) {
+  const value = callOptionsOf(options)?.signal;
+  return value instanceof AbortSignal ? value : void 0;
+}
+function wireOptions(options) {
+  if (callOptionsOf(options) === void 0)
+    return options;
+  const { signal: _signal, timeoutMs: _timeoutMs, ...rest } = options;
+  void _signal;
+  void _timeoutMs;
+  return rest;
+}
+function wireData(data) {
+  if (typeof data === "string" || Buffer.isBuffer(data))
+    return data;
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return data;
+}
+function asBuffer(value) {
+  if (Buffer.isBuffer(value))
+    return value;
+  const bytes = value;
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function stringOrBuffer(value) {
+  return typeof value === "string" ? value : asBuffer(value);
+}
+function asStats(value) {
+  return Object.assign(Object.create(Stats.prototype), value);
+}
+function asDirent(value) {
+  const entry = value;
+  const DirentClass = Dirent;
+  const name = typeof entry.name === "string" ? entry.name : asBuffer(entry.name);
+  return new DirentClass(name, entry.type, entry.parentPath);
+}
+function asEntries(value, withFileTypes2) {
+  const list = value;
+  if (withFileTypes2)
+    return list.map(asDirent);
+  return list.map((entry) => typeof entry === "string" ? entry : asBuffer(entry));
+}
+function assignFields(target, fields) {
+  for (const [key, value] of Object.entries(fields)) {
+    if (value !== void 0) {
+      Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+  return target;
+}
+var ERROR_CLASSES = {
+  TypeError,
+  RangeError,
+  SyntaxError
+};
+function nodeError(error) {
+  const ErrorClass = ERROR_CLASSES[error.name ?? ""] ?? Error;
+  const rebuilt = new ErrorClass(error.message);
+  if (error.name !== void 0 && error.name !== rebuilt.name) {
+    rebuilt.name = error.name;
+  }
+  return assignFields(rebuilt, {
+    errno: error.errno,
+    code: error.code,
+    syscall: error.syscall,
+    path: error.path,
+    dest: error.dest
+  });
+}
+function kayError(code, detail, syscall, path) {
+  return assignFields(new Error(`${code}: ${detail}, ${syscall}${path === void 0 ? "" : ` '${path}'`}`), { code, syscall, path });
+}
+function abortError(signal) {
+  const error = new Error("The operation was aborted", {
+    cause: signal?.reason
+  });
+  error.name = "AbortError";
+  return assignFields(error, { code: "ABORT_ERR" });
+}
+function unsupported(syscall, what) {
+  return kayError(KAY_FS_UNSUPPORTED, `${what} is not supported by @kay/plugin-sdk/fs`, syscall, void 0);
+}
+function finishedOf(error) {
+  return error?.[FINISHED];
+}
+var TIMEOUT_CODES = {
+  deadline: KAY_FS_DEADLINE,
+  "cooling-down": KAY_FS_COOLING_DOWN,
+  saturated: KAY_FS_SATURATED
+};
+function unwrap(result, syscall, path, signal) {
+  switch (result.kind) {
+    case "ok":
+      return result.value;
+    case "error":
+      throw nodeError(result.error);
+    case "aborted": {
+      const error = abortError(signal);
+      if (result.finished !== void 0) {
+        Object.defineProperty(error, FINISHED, { value: result.finished });
+      }
+      throw error;
+    }
+    case "unavailable":
+      throw kayError(KAY_FS_UNAVAILABLE, result.detail, syscall, path);
+    case "timeout": {
+      const error = kayError(TIMEOUT_CODES[result.reason], result.detail, syscall, path);
+      if (result.reason === "deadline") {
+        Object.defineProperty(error, FINISHED, { value: result.finished });
+      }
+      throw error;
+    }
+  }
+}
+async function invoke(backend, name, args, options) {
+  if (options.signal?.aborted === true)
+    throw abortError(options.signal);
+  const request = {
+    op: "call",
+    name,
+    args,
+    paths: options.paths,
+    timeoutMs: options.timeoutMs ?? timeoutOf(void 0),
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    ...options.opensFd === true ? { opensFd: true } : {},
+    ...options.walksTree === true ? { walksTree: true } : {}
+  };
+  return unwrap(await backend.run(request), name, options.paths[0], options.signal);
+}
+
+// packages/plugin-sdk/dist/fs/handle.js
+var DEFAULT_READ_BYTES = 16 * 1024;
+var STREAM_HIGH_WATER_MARK = 64 * 1024;
+function closeDescriptor(token) {
+  return token.backend.run({
+    op: "call",
+    name: "close",
+    args: [token.fd],
+    paths: [],
+    timeoutMs: KAY_FS_DEFAULT_TIMEOUT_MS
+  });
+}
+function closeWhenIdle(token) {
+  void Promise.all(token.workers).then(() => closeDescriptor(token));
+}
+var collector = new FinalizationRegistry(closeWhenIdle);
+function bytesOf(view) {
+  return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+function positionOf(value) {
+  if (typeof value === "bigint")
+    return Number(value);
+  return typeof value === "number" && value >= 0 ? value : null;
+}
+function readArgs(args) {
+  const [first, second, third, fourth] = args;
+  if (first === void 0 || !ArrayBuffer.isView(first) && typeof first === "object") {
+    const options = first ?? {};
+    const buffer2 = options["buffer"] ?? Buffer2.alloc(DEFAULT_READ_BYTES);
+    const offset2 = options["offset"] ?? 0;
+    return {
+      buffer: buffer2,
+      offset: offset2,
+      length: options["length"] ?? buffer2.byteLength - offset2,
+      position: positionOf(options["position"])
+    };
+  }
+  const buffer = first;
+  if (typeof second === "object" && second !== null) {
+    const options = second;
+    const offset2 = options["offset"] ?? 0;
+    return {
+      buffer,
+      offset: offset2,
+      length: options["length"] ?? buffer.byteLength - offset2,
+      position: positionOf(options["position"])
+    };
+  }
+  const offset = second ?? 0;
+  return {
+    buffer,
+    offset,
+    length: third ?? buffer.byteLength - offset,
+    position: positionOf(fourth)
+  };
+}
+var KayFileHandle = class extends EventEmitter {
+  #fd;
+  #path;
+  #backend;
+  #token;
+  /** Calls whose caller has not been answered yet; `close()` waits for them. */
+  #callers = /* @__PURE__ */ new Set();
+  #closed = false;
+  /** Set when a call missed its deadline: settles once that call stops running. */
+  #stuck;
+  constructor(fd, path, backend) {
+    super();
+    this.#fd = fd;
+    this.#path = path;
+    this.#backend = backend;
+    this.#token = { fd, backend, workers: /* @__PURE__ */ new Set() };
+    collector.register(this, this.#token, this);
+  }
+  get fd() {
+    return this.#fd;
+  }
+  #usable(syscall) {
+    if (this.#closed) {
+      throw Object.assign(new Error("file closed"), { code: "EBADF", syscall });
+    }
+    if (this.#stuck !== void 0) {
+      throw kayError(KAY_FS_DEADLINE, "an earlier call on this file handle did not finish; it can only be closed", syscall, this.#path);
+    }
+  }
+  async #settle(syscall, run, signal) {
+    this.#usable(syscall);
+    if (signal?.aborted === true)
+      throw abortError(signal);
+    const workers = this.#token.workers;
+    let workerDone;
+    const worker = new Promise((resolveWorker) => {
+      workerDone = () => {
+        workers.delete(worker);
+        resolveWorker();
+      };
+    });
+    workers.add(worker);
+    const pending = run();
+    this.#callers.add(pending);
+    let result;
+    try {
+      result = await pending;
+    } finally {
+      this.#callers.delete(pending);
+    }
+    const finished = "finished" in result ? result.finished : void 0;
+    if (finished === void 0)
+      workerDone();
+    else
+      void finished.then(workerDone);
+    try {
+      return unwrap(result, syscall, this.#path, signal);
+    } catch (error) {
+      if (result.kind === "timeout")
+        this.#stuck = finishedOf(error);
+      throw error;
+    }
+  }
+  #call(name, args, options) {
+    const signal = signalOf(options);
+    return this.#settle(name, () => this.#backend.run({
+      op: "call",
+      name,
+      args: [this.#fd, ...args],
+      paths: [this.#path],
+      timeoutMs: timeoutOf(options),
+      ...signal === void 0 ? {} : { signal }
+    }), signal);
+  }
+  async read(...args) {
+    const { buffer, offset, length, position } = readArgs(args);
+    if (length === 0)
+      return { bytesRead: 0, buffer };
+    const value = await this.#settle("read", () => this.#backend.run({
+      op: "read",
+      fd: this.#fd,
+      length,
+      position,
+      paths: [this.#path],
+      timeoutMs: timeoutOf(void 0)
+    }));
+    bytesOf(buffer).set(value.bytes, offset);
+    return { bytesRead: value.bytesRead, buffer };
+  }
+  async readv(buffers, position) {
+    let bytesRead = 0;
+    let at = positionOf(position);
+    for (const buffer of buffers) {
+      const { bytesRead: n } = await this.read(buffer, 0, buffer.byteLength, at);
+      bytesRead += n;
+      if (at !== null)
+        at += n;
+      if (n < buffer.byteLength)
+        break;
+    }
+    return { bytesRead, buffers: [...buffers] };
+  }
+  async write(data, ...rest) {
+    if (typeof data === "string") {
+      const [position2, encoding] = rest;
+      const bytesWritten2 = await this.#call("write", [
+        data,
+        positionOf(position2),
+        encoding ?? "utf8"
+      ]);
+      return { bytesWritten: bytesWritten2, buffer: data };
+    }
+    const view = data;
+    const options = isOptionsObject(rest[0]) ? rest[0] : void 0;
+    const offset = options === void 0 ? rest[0] ?? 0 : options["offset"] ?? 0;
+    const length = options === void 0 ? rest[1] ?? view.byteLength - offset : options["length"] ?? view.byteLength - offset;
+    const position = positionOf(options === void 0 ? rest[2] : options["position"]);
+    const bytes = bytesOf(view).slice(offset, offset + length);
+    const bytesWritten = await this.#call("write", [
+      bytes,
+      0,
+      length,
+      position
+    ]);
+    return { bytesWritten, buffer: data };
+  }
+  async writev(buffers, position) {
+    let bytesWritten = 0;
+    let at = positionOf(position);
+    for (const buffer of buffers) {
+      const n = await this.#writeAll(bytesOf(buffer), at);
+      bytesWritten += n;
+      if (at !== null)
+        at += n;
+    }
+    return { bytesWritten, buffers: [...buffers] };
+  }
+  async #writeAll(bytes, position) {
+    let written = 0;
+    while (written < bytes.byteLength) {
+      const { bytesWritten } = await this.write(bytes, written, bytes.byteLength - written, position === null ? null : position + written);
+      if (bytesWritten === 0)
+        break;
+      written += bytesWritten;
+    }
+    return written;
+  }
+  async readFile(options) {
+    return stringOrBuffer(await this.#call("readFile", [wireOptions(options)], options));
+  }
+  async writeFile(data, options) {
+    if (typeof data === "string" || ArrayBuffer.isView(data)) {
+      await this.#call("writeFile", [wireData(data), wireOptions(options)], options);
+      return;
+    }
+    const encoding = typeof options === "string" ? options : options?.encoding ?? "utf8";
+    for await (const chunk of data) {
+      const bytes = typeof chunk === "string" ? Buffer2.from(chunk, encoding) : bytesOf(chunk);
+      await this.#writeAll(bytes, null);
+    }
+  }
+  async appendFile(data, options) {
+    if (typeof data === "string" || ArrayBuffer.isView(data)) {
+      await this.#call("appendFile", [wireData(data), wireOptions(options)], options);
+      return;
+    }
+    await this.writeFile(data, options);
+  }
+  async stat(options) {
+    if (options?.bigint === true)
+      throw unsupported("fstat", "bigint stats");
+    return asStats(await this.#call("fstat", []));
+  }
+  async truncate(length) {
+    await this.#call("ftruncate", [length ?? 0]);
+  }
+  async sync() {
+    await this.#call("fsync", []);
+  }
+  async datasync() {
+    await this.#call("fdatasync", []);
+  }
+  async utimes(atime, mtime) {
+    await this.#call("futimes", [atime, mtime]);
+  }
+  async chmod(mode) {
+    await this.#call("fchmod", [mode]);
+  }
+  async chown(uid, gid) {
+    await this.#call("fchown", [uid, gid]);
+  }
+  /**
+   * Like Node's, waits for calls still pending on this handle, then closes the fd. A call that
+   * missed its deadline or was aborted may leave a worker inside it: closing then could hand the
+   * fd's number to a new file mid-call, so the host closes it once that call returns, and this
+   * answers without waiting for that.
+   */
+  async close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#fd = -1;
+    collector.unregister(this);
+    try {
+      await Promise.allSettled(this.#callers);
+      if (this.#token.workers.size > 0) {
+        closeWhenIdle(this.#token);
+        return;
+      }
+      unwrap(await closeDescriptor(this.#token), "close", this.#path);
+    } finally {
+      this.emit("close");
+    }
+  }
+  [Symbol.asyncDispose]() {
+    return this.close();
+  }
+  createReadStream(options) {
+    const highWaterMark = options?.highWaterMark ?? STREAM_HIGH_WATER_MARK;
+    const end = options?.end ?? Number.POSITIVE_INFINITY;
+    let position = options?.start ?? (options?.end === void 0 ? null : 0);
+    const autoClose = options?.autoClose ?? true;
+    const stream = new Readable({
+      highWaterMark,
+      read: () => {
+        const remaining = position === null ? highWaterMark : Math.min(highWaterMark, end - position + 1);
+        if (remaining <= 0) {
+          stream.push(null);
+          return;
+        }
+        this.read(Buffer2.allocUnsafe(remaining), 0, remaining, position).then(({ bytesRead, buffer }) => {
+          if (bytesRead === 0) {
+            stream.push(null);
+            return;
+          }
+          if (position !== null)
+            position += bytesRead;
+          stream.push(buffer.subarray(0, bytesRead));
+        }, (error) => stream.destroy(error));
+      },
+      destroy: (error, callback) => {
+        if (!autoClose) {
+          callback(error);
+          return;
+        }
+        this.close().then(() => callback(error), (closeError) => callback(error ?? closeError));
+      }
+    });
+    if (options?.encoding !== void 0 && options.encoding !== null) {
+      stream.setEncoding(options.encoding);
+    }
+    return stream;
+  }
+  createWriteStream(options) {
+    let position = options?.start ?? null;
+    const autoClose = options?.autoClose ?? true;
+    const encoding = options?.encoding ?? "utf8";
+    const stream = new Writable({
+      highWaterMark: options?.highWaterMark ?? STREAM_HIGH_WATER_MARK,
+      // Strings written without an encoding are encoded with the stream's, as Node's are.
+      defaultEncoding: encoding,
+      write: (chunk, chunkEncoding, callback) => {
+        const bytes = typeof chunk === "string" ? Buffer2.from(chunk, chunkEncoding === "buffer" ? encoding : chunkEncoding) : bytesOf(chunk);
+        this.#writeAll(bytes, position).then((written) => {
+          if (position !== null)
+            position += written;
+          callback();
+        }, (error) => callback(error));
+      },
+      final: (callback) => {
+        if (options?.flush !== true) {
+          callback();
+          return;
+        }
+        this.sync().then(() => callback(), (error) => callback(error));
+      },
+      destroy: (error, callback) => {
+        if (!autoClose) {
+          callback(error);
+          return;
+        }
+        this.close().then(() => callback(error), (closeError) => callback(error ?? closeError));
+      }
+    });
+    return stream;
+  }
+  readLines(options) {
+    return createInterface({
+      input: this.createReadStream(options),
+      crlfDelay: Number.POSITIVE_INFINITY
+    });
+  }
+  readableWebStream() {
+    return Readable.toWeb(this.createReadStream());
+  }
+};
+function asFileHandle(handle) {
+  return handle;
+}
+var KayDir = class {
+  path;
+  #entries;
+  #closed = false;
+  constructor(path, entries) {
+    this.path = path;
+    this.#entries = entries;
+  }
+  async read() {
+    if (this.#closed) {
+      throw Object.assign(new Error("Directory handle was closed"), {
+        code: "ERR_DIR_CLOSED"
+      });
+    }
+    return this.#entries.shift() ?? null;
+  }
+  async close() {
+    this.#closed = true;
+  }
+  readSync() {
+    throw unsupported("readdir", "Dir.readSync");
+  }
+  closeSync() {
+    throw unsupported("closedir", "Dir.closeSync");
+  }
+  async *[Symbol.asyncIterator]() {
+    try {
+      const first = await this.read();
+      if (first === null)
+        return;
+      yield first;
+      yield* this.#entries.splice(0);
+    } finally {
+      await this.close();
+    }
+  }
+  [Symbol.asyncDispose]() {
+    return this.close();
+  }
+  [Symbol.dispose]() {
+    this.#closed = true;
+  }
+};
+
+// packages/plugin-sdk/dist/fs/host.js
+var KAY_FS_BACKEND = Symbol.for("kay.plugin-sdk.fs.backend.v1");
+function currentKayFsBackend() {
+  return globalThis[KAY_FS_BACKEND];
+}
+
+// packages/plugin-sdk/dist/fs/index.js
+function route(node, host) {
+  return ((...args) => {
+    const backend = currentKayFsBackend();
+    if (backend === void 0) {
+      return node()(...args);
+    }
+    try {
+      return host(backend, ...args);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  });
+}
+function lastOptions(args) {
+  const last = args.at(-1);
+  return isOptionsObject(last) ? last : void 0;
+}
+function recursive(options) {
+  return options?.recursive === true;
+}
+function onPath(backend, name, path, rest, walksTree = false) {
+  const options = lastOptions(rest);
+  const signal = signalOf(options);
+  return invoke(backend, name, [
+    wirePath(path),
+    ...rest.map((arg) => arg === options ? wireOptions(arg) : arg)
+  ], {
+    paths: [keyPath(path)],
+    timeoutMs: timeoutOf(options),
+    walksTree,
+    ...signal === void 0 ? {} : { signal }
+  });
+}
+function onTwoPaths(backend, name, from, to, rest, walksTree = false) {
+  const options = lastOptions(rest);
+  return invoke(backend, name, [
+    wirePath(from),
+    wirePath(to),
+    ...rest.map((arg) => arg === options ? wireOptions(arg) : arg)
+  ], {
+    paths: [keyPath(from), keyPath(to)],
+    timeoutMs: timeoutOf(options),
+    walksTree
+  });
+}
+function rejectBigint(syscall, options) {
+  if (options?.bigint === true) {
+    throw unsupported(syscall, "bigint stats");
+  }
+}
+function withFileTypes(options) {
+  return options?.withFileTypes === true;
+}
+var isHandle = (value) => value instanceof KayFileHandle;
+var voidResult = async (pending) => {
+  await pending;
+};
+var access2 = route(() => nodeFsp.access, (backend, path, ...rest) => voidResult(onPath(backend, "access", path, rest)));
+var appendFile2 = route(() => nodeFsp.appendFile, (backend, path, data, options) => isHandle(path) ? path.appendFile(data, options) : voidResult(onPath(backend, "appendFile", path, [wireData(data), options])));
+var chmod2 = route(() => nodeFsp.chmod, (backend, path, mode) => voidResult(onPath(backend, "chmod", path, [mode])));
+var chown2 = route(() => nodeFsp.chown, (backend, path, uid, gid) => voidResult(onPath(backend, "chown", path, [uid, gid])));
+var lchown2 = route(() => nodeFsp.lchown, (backend, path, uid, gid) => voidResult(onPath(backend, "lchown", path, [uid, gid])));
+var lchmod2 = route(() => nodeFsp.lchmod, async () => {
+  throw unsupported("lchmod", "lchmod");
+});
+var copyFile2 = route(() => nodeFsp.copyFile, (backend, from, to, mode) => voidResult(onTwoPaths(backend, "copyFile", from, to, mode === void 0 ? [] : [mode])));
+var cp2 = route(() => nodeFsp.cp, async (backend, from, to, options) => {
+  if (typeof options?.filter === "function") {
+    throw unsupported("cp", "a cp filter function");
+  }
+  await onTwoPaths(backend, "cp", from, to, options === void 0 ? [] : [options], recursive(options));
+});
+var link2 = route(() => nodeFsp.link, (backend, existing, created) => voidResult(onTwoPaths(backend, "link", existing, created, [])));
+var symlink2 = route(
+  () => nodeFsp.symlink,
+  // The target is stored as text and may be relative to the link, so only the link is a path.
+  (backend, target, path, type) => voidResult(invoke(backend, "symlink", [wirePath(target), wirePath(path), type ?? null], {
+    paths: [keyPath(path)]
+  }))
+);
+var lstat2 = route(() => nodeFsp.lstat, async (backend, path, options) => {
+  rejectBigint("lstat", options);
+  return asStats(await onPath(backend, "lstat", path, options === void 0 ? [] : [options]));
+});
+var stat2 = route(() => nodeFsp.stat, async (backend, path, options) => {
+  rejectBigint("stat", options);
+  return asStats(await onPath(backend, "stat", path, options === void 0 ? [] : [options]));
+});
+var statfs2 = route(() => nodeFsp.statfs, async (backend, path, options) => {
+  rejectBigint("statfs", options);
+  return onPath(backend, "statfs", path, options === void 0 ? [] : [options]);
+});
+var lutimes2 = route(() => nodeFsp.lutimes, (backend, path, atime, mtime) => voidResult(onPath(backend, "lutimes", path, [atime, mtime])));
+var utimes2 = route(() => nodeFsp.utimes, (backend, path, atime, mtime) => voidResult(onPath(backend, "utimes", path, [atime, mtime])));
+var mkdir2 = route(() => nodeFsp.mkdir, async (backend, path, options) => {
+  const created = await onPath(backend, "mkdir", path, options === void 0 ? [] : [options]);
+  return created === null ? void 0 : created;
+});
+var mkdtemp2 = route(() => nodeFsp.mkdtemp, async (backend, prefix, options) => stringOrBuffer(await invoke(backend, "mkdtemp", [wirePath(prefix), wireOptions(options) ?? null], {
+  paths: [dirname(keyPath(prefix))],
+  timeoutMs: timeoutOf(options)
+})));
+var mkdtempDisposable2 = route(() => nodeFsp.mkdtempDisposable, async (_backend, prefix, options) => {
+  const path = await mkdtemp2(prefix, options);
+  const remove = () => rm2(path, { recursive: true, force: true });
+  return { path, remove, [Symbol.asyncDispose]: remove };
+});
+var open2 = route(() => nodeFsp.open, async (backend, path, flags, mode) => {
+  const fd = await invoke(backend, "open", [wirePath(path), flags ?? "r", mode ?? 438], { paths: [keyPath(path)], opensFd: true });
+  return asFileHandle(new KayFileHandle(fd, keyPath(path), backend));
+});
+var readdir2 = route(() => nodeFsp.readdir, async (backend, path, options) => asEntries(await onPath(backend, "readdir", path, options === void 0 ? [] : [options], recursive(options)), withFileTypes(options)));
+var opendir2 = route(() => nodeFsp.opendir, async (backend, path, options) => {
+  const walks = recursive(options);
+  const entries = asEntries(await onPath(backend, "readdir", path, [{ withFileTypes: true, recursive: walks }], walks), true);
+  const shown = typeof path === "string" ? path : keyPath(path);
+  return new KayDir(shown, entries);
+});
+var readFile2 = route(() => nodeFsp.readFile, async (backend, path, options) => isHandle(path) ? path.readFile(options) : stringOrBuffer(await onPath(backend, "readFile", path, options === void 0 ? [] : [options])));
+var readlink2 = route(() => nodeFsp.readlink, async (backend, path, options) => stringOrBuffer(await onPath(backend, "readlink", path, options === void 0 ? [] : [options])));
+var realpath2 = route(() => nodeFsp.realpath, async (backend, path, options) => stringOrBuffer(await onPath(backend, "realpath", path, options === void 0 ? [] : [options])));
+var rename2 = route(() => nodeFsp.rename, (backend, from, to) => voidResult(onTwoPaths(backend, "rename", from, to, [])));
+var rm2 = route(() => nodeFsp.rm, (backend, path, options) => voidResult(onPath(backend, "rm", path, options === void 0 ? [] : [options], recursive(options))));
+var rmdir2 = route(() => nodeFsp.rmdir, (backend, path, options) => voidResult(onPath(backend, "rmdir", path, options === void 0 ? [] : [options])));
+var truncate2 = route(() => nodeFsp.truncate, (backend, path, length) => voidResult(onPath(backend, "truncate", path, [length ?? 0])));
+var unlink2 = route(() => nodeFsp.unlink, (backend, path) => voidResult(onPath(backend, "unlink", path, [])));
+var writeFile2 = route(() => nodeFsp.writeFile, async (backend, path, data, options) => {
+  if (isHandle(path))
+    return path.writeFile(data, options);
+  if (typeof data === "string" || ArrayBuffer.isView(data)) {
+    await onPath(backend, "writeFile", path, [wireData(data), options]);
+    return;
+  }
+  const flag = options?.flag ?? "w";
+  const mode = options?.mode;
+  const handle = await open2(path, flag, mode);
+  try {
+    await handle.writeFile(data, options);
+  } finally {
+    await handle.close();
+  }
+});
+var glob2 = route(() => nodeFsp.glob, (backend, pattern, options) => {
+  const exclude = options?.exclude;
+  const cwd = options?.cwd;
+  return (async function* () {
+    if (typeof exclude === "function") {
+      throw unsupported("glob", "a glob exclude function");
+    }
+    const wire = wireOptions(options);
+    const found = await invoke(backend, "glob", [
+      pattern,
+      wire === void 0 ? {} : { ...wire, ...cwd === void 0 ? {} : { cwd: wirePath(cwd) } }
+    ], {
+      paths: [cwd === void 0 ? resolve2(".") : keyPath(cwd)],
+      timeoutMs: timeoutOf(options),
+      walksTree: true
+    });
+    yield* asEntries(found, withFileTypes(options));
+  })();
+});
+var watch2 = route(
+  () => nodeFsp.watch,
+  // Node returns the iterator at once and fails on iteration; so does this.
+  () => (async function* () {
+    yield* [];
+    throw unsupported("watch", "fs watching (it has its own host worker)");
+  })()
+);
+async function writeFileAtomic(path, data, options) {
+  if (options?.timeoutMs !== void 0) {
+    const { timeoutMs, ...rest } = options;
+    return withTimeout(timeoutMs, () => writeFileAtomic(path, data, rest));
+  }
+  const target = keyPath(path);
+  const folder = dirname(target);
+  const temporary = join(folder, `.${basename(target)}.${globalThis.crypto.randomUUID()}.tmp`);
+  const handle = await open2(temporary, "wx", options?.mode ?? 438);
+  try {
+    await handle.writeFile(typeof data === "string" ? Buffer3.from(data, options?.encoding ?? "utf8") : new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    await handle.sync();
+    await handle.close();
+    await rename2(temporary, target);
+  } catch (error) {
+    await handle.close().catch(() => void 0);
+    await rm2(temporary, { force: true }).catch(() => void 0);
+    throw error;
+  }
+  if (process.platform !== "win32") {
+    try {
+      const directory = await open2(folder, "r");
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+    } catch {
+    }
+  }
+}
+var index_default = {
+  access: access2,
+  appendFile: appendFile2,
+  chmod: chmod2,
+  chown: chown2,
+  constants,
+  copyFile: copyFile2,
+  cp: cp2,
+  glob: glob2,
+  lchmod: lchmod2,
+  lchown: lchown2,
+  link: link2,
+  lstat: lstat2,
+  lutimes: lutimes2,
+  mkdir: mkdir2,
+  mkdtemp: mkdtemp2,
+  mkdtempDisposable: mkdtempDisposable2,
+  open: open2,
+  opendir: opendir2,
+  readdir: readdir2,
+  readFile: readFile2,
+  readlink: readlink2,
+  realpath: realpath2,
+  rename: rename2,
+  rm: rm2,
+  rmdir: rmdir2,
+  stat: stat2,
+  statfs: statfs2,
+  symlink: symlink2,
+  truncate: truncate2,
+  unlink: unlink2,
+  utimes: utimes2,
+  watch: watch2,
+  writeFile: writeFile2,
+  writeFileAtomic,
+  withTimeout
+};
+export {
+  KAY_FS_COOLING_DOWN,
+  KAY_FS_DEADLINE,
+  KAY_FS_DEFAULT_TIMEOUT_MS,
+  KAY_FS_SATURATED,
+  KAY_FS_UNAVAILABLE,
+  KAY_FS_UNSUPPORTED,
+  access2 as access,
+  appendFile2 as appendFile,
+  chmod2 as chmod,
+  chown2 as chown,
+  constants,
+  copyFile2 as copyFile,
+  cp2 as cp,
+  index_default as default,
+  glob2 as glob,
+  lchmod2 as lchmod,
+  lchown2 as lchown,
+  link2 as link,
+  lstat2 as lstat,
+  lutimes2 as lutimes,
+  mkdir2 as mkdir,
+  mkdtemp2 as mkdtemp,
+  mkdtempDisposable2 as mkdtempDisposable,
+  open2 as open,
+  opendir2 as opendir,
+  readFile2 as readFile,
+  readdir2 as readdir,
+  readlink2 as readlink,
+  realpath2 as realpath,
+  rename2 as rename,
+  rm2 as rm,
+  rmdir2 as rmdir,
+  stat2 as stat,
+  statfs2 as statfs,
+  symlink2 as symlink,
+  truncate2 as truncate,
+  unlink2 as unlink,
+  utimes2 as utimes,
+  watch2 as watch,
+  withTimeout,
+  writeFile2 as writeFile,
+  writeFileAtomic
+};