@ai-switch/tauri-plugin-runtime 0.1.0

package/dist/host/policy.d.ts

@@ -0,0 +1,7 @@
+export declare function checkedTimeout(value: number): number;
+export declare function checkedOrigin(origin: string): string;
+export declare function requireAssetOrigin(assetUrl: string, origins: readonly string[]): void;
+export declare function randomId(prefix?: string): string;
+export declare function randomNonce(): string;
+/** Bound a trusted control operation even if its physical transport cannot abort. */
+export declare function bounded<T>(operation: () => Promise<T>, timeoutMs: number): Promise<T>;

package/dist/host/requests.d.ts

@@ -0,0 +1,13 @@
+import type { JsonObject, JsonValue } from "../protocol/types.js";
+import type { HostTransport } from "../protocol/wire.js";
+type Operation = "capability.call" | "subscription.open";
+export interface SessionRequests {
+    run(operation: Operation, args: JsonObject, signal?: AbortSignal, onLate?: (result: JsonValue) => void | Promise<void>): Promise<JsonValue>;
+    abortAll(reason: Error): void;
+}
+export declare function createSessionRequests(options: {
+    transport: HostTransport;
+    sessionId: string;
+    timeoutMs: number;
+}): SessionRequests;
+export {};

package/dist/host/types.d.ts

@@ -0,0 +1,19 @@
+import type { HostTransport } from "../protocol/wire.js";
+export interface PluginView {
+    readonly pluginId: string;
+    readonly element: HTMLIFrameElement;
+    dispose(): Promise<void>;
+}
+export interface PluginHost {
+    mount(options: {
+        pluginId: string;
+        container: HTMLElement;
+    }): Promise<PluginView>;
+    dispose(): Promise<void>;
+}
+export interface PluginHostOptions {
+    transport: HostTransport;
+    allowedAssetOrigins?: string[];
+    handshakeTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}

package/dist/host/view.d.ts

@@ -0,0 +1,18 @@
+import type { HostEvent, SessionDescriptor } from "../protocol/generated/types.generated.js";
+import type { HostTransport } from "../protocol/wire.js";
+import type { PluginView } from "./types.js";
+export interface ManagedView {
+    view: PluginView;
+    ready: Promise<PluginView>;
+    accept(event: HostEvent): void;
+    dispose(reason?: Error): Promise<void>;
+}
+export declare function createManagedView(options: {
+    descriptor: SessionDescriptor;
+    container: HTMLElement;
+    transport: HostTransport;
+    handshakeTimeoutMs: number;
+    requestTimeoutMs: number;
+    closeSession(): Promise<void>;
+    onDisposed(): void;
+}): ManagedView;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { apiVersion, protocolVersion } from "./protocol/limits.js";
+export type { Manifest, JsonValue, JsonObject, Diagnostic, ValidationResult } from "./protocol/index.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+import {
+  apiVersion,
+  protocolVersion
+} from "./chunk-WT62GTMC.js";
+import "./chunk-JSBRDJBE.js";
+export {
+  apiVersion,
+  protocolVersion
+};

package/dist/node/buffer.d.ts

@@ -0,0 +1,7 @@
+import { Buffer as BrowserBuffer } from "buffer/index.js";
+declare module "buffer/index.js" {
+    interface Buffer {
+        subarray(start?: number, end?: number): Buffer;
+    }
+}
+export { BrowserBuffer as Buffer };

package/dist/node/buffer.js

@@ -0,0 +1,8 @@
+import {
+  import_buffer
+} from "../chunk-CFQSUF5W.js";
+import "../chunk-JSBRDJBE.js";
+var export_Buffer = import_buffer.Buffer;
+export {
+  export_Buffer as Buffer
+};

package/dist/node/events.d.ts

@@ -0,0 +1,12 @@
+export type EventName = string | symbol;
+export type EventListener = (this: EventEmitter, ...args: any[]) => void;
+/** Intentionally exposes only the portable five-method listener/emit subset. */
+export declare class EventEmitter {
+    #private;
+    on(event: EventName, listener: EventListener): this;
+    once(event: EventName, listener: EventListener): this;
+    off(event: EventName, listener: EventListener): this;
+    emit(event: EventName, ...args: unknown[]): boolean;
+    removeAllListeners(event?: EventName): this;
+}
+export default EventEmitter;

package/dist/node/events.js

@@ -0,0 +1,458 @@
+import {
+  __commonJS,
+  __toESM
+} from "../chunk-JSBRDJBE.js";
+
+// ../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js
+var require_events = __commonJS({
+  "../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js"(exports, module) {
+    "use strict";
+    var R = typeof Reflect === "object" ? Reflect : null;
+    var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+      return Function.prototype.apply.call(target, receiver, args);
+    };
+    var ReflectOwnKeys;
+    if (R && typeof R.ownKeys === "function") {
+      ReflectOwnKeys = R.ownKeys;
+    } else if (Object.getOwnPropertySymbols) {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+      };
+    } else {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target);
+      };
+    }
+    function ProcessEmitWarning(warning) {
+      if (console && console.warn) console.warn(warning);
+    }
+    var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+      return value !== value;
+    };
+    function EventEmitter2() {
+      EventEmitter2.init.call(this);
+    }
+    module.exports = EventEmitter2;
+    module.exports.once = once;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    EventEmitter2.prototype._events = void 0;
+    EventEmitter2.prototype._eventsCount = 0;
+    EventEmitter2.prototype._maxListeners = void 0;
+    var defaultMaxListeners = 10;
+    function checkListener2(listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+      }
+    }
+    Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
+      enumerable: true,
+      get: function() {
+        return defaultMaxListeners;
+      },
+      set: function(arg) {
+        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+        }
+        defaultMaxListeners = arg;
+      }
+    });
+    EventEmitter2.init = function() {
+      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      }
+      this._maxListeners = this._maxListeners || void 0;
+    };
+    EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n) {
+      if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+      }
+      this._maxListeners = n;
+      return this;
+    };
+    function _getMaxListeners(that) {
+      if (that._maxListeners === void 0)
+        return EventEmitter2.defaultMaxListeners;
+      return that._maxListeners;
+    }
+    EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
+      return _getMaxListeners(this);
+    };
+    EventEmitter2.prototype.emit = function emit(type) {
+      var args = [];
+      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+      var doError = type === "error";
+      var events = this._events;
+      if (events !== void 0)
+        doError = doError && events.error === void 0;
+      else if (!doError)
+        return false;
+      if (doError) {
+        var er;
+        if (args.length > 0)
+          er = args[0];
+        if (er instanceof Error) {
+          throw er;
+        }
+        var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+        err.context = er;
+        throw err;
+      }
+      var handler = events[type];
+      if (handler === void 0)
+        return false;
+      if (typeof handler === "function") {
+        ReflectApply(handler, this, args);
+      } else {
+        var len = handler.length;
+        var listeners = arrayClone(handler, len);
+        for (var i = 0; i < len; ++i)
+          ReflectApply(listeners[i], this, args);
+      }
+      return true;
+    };
+    function _addListener(target, type, listener, prepend) {
+      var m;
+      var events;
+      var existing;
+      checkListener2(listener);
+      events = target._events;
+      if (events === void 0) {
+        events = target._events = /* @__PURE__ */ Object.create(null);
+        target._eventsCount = 0;
+      } else {
+        if (events.newListener !== void 0) {
+          target.emit(
+            "newListener",
+            type,
+            listener.listener ? listener.listener : listener
+          );
+          events = target._events;
+        }
+        existing = events[type];
+      }
+      if (existing === void 0) {
+        existing = events[type] = listener;
+        ++target._eventsCount;
+      } else {
+        if (typeof existing === "function") {
+          existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+        } else if (prepend) {
+          existing.unshift(listener);
+        } else {
+          existing.push(listener);
+        }
+        m = _getMaxListeners(target);
+        if (m > 0 && existing.length > m && !existing.warned) {
+          existing.warned = true;
+          var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+          w.name = "MaxListenersExceededWarning";
+          w.emitter = target;
+          w.type = type;
+          w.count = existing.length;
+          ProcessEmitWarning(w);
+        }
+      }
+      return target;
+    }
+    EventEmitter2.prototype.addListener = function addListener(type, listener) {
+      return _addListener(this, type, listener, false);
+    };
+    EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
+    EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
+    function onceWrapper() {
+      if (!this.fired) {
+        this.target.removeListener(this.type, this.wrapFn);
+        this.fired = true;
+        if (arguments.length === 0)
+          return this.listener.call(this.target);
+        return this.listener.apply(this.target, arguments);
+      }
+    }
+    function _onceWrap(target, type, listener) {
+      var state = { fired: false, wrapFn: void 0, target, type, listener };
+      var wrapped = onceWrapper.bind(state);
+      wrapped.listener = listener;
+      state.wrapFn = wrapped;
+      return wrapped;
+    }
+    EventEmitter2.prototype.once = function once2(type, listener) {
+      checkListener2(listener);
+      this.on(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+      checkListener2(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+      checkListener2(listener);
+      events = this._events;
+      if (events === void 0)
+        return this;
+      list = events[type];
+      if (list === void 0)
+        return this;
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit("removeListener", type, list.listener || listener);
+        }
+      } else if (typeof list !== "function") {
+        position = -1;
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+        if (position < 0)
+          return this;
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
+        if (list.length === 1)
+          events[type] = list[0];
+        if (events.removeListener !== void 0)
+          this.emit("removeListener", type, originalListener || listener);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
+      var listeners, events, i;
+      events = this._events;
+      if (events === void 0)
+        return this;
+      if (events.removeListener === void 0) {
+        if (arguments.length === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== void 0) {
+          if (--this._eventsCount === 0)
+            this._events = /* @__PURE__ */ Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === "removeListener") continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners("removeListener");
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+      listeners = events[type];
+      if (typeof listeners === "function") {
+        this.removeListener(type, listeners);
+      } else if (listeners !== void 0) {
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+      return this;
+    };
+    function _listeners(target, type, unwrap) {
+      var events = target._events;
+      if (events === void 0)
+        return [];
+      var evlistener = events[type];
+      if (evlistener === void 0)
+        return [];
+      if (typeof evlistener === "function")
+        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+      return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+    }
+    EventEmitter2.prototype.listeners = function listeners(type) {
+      return _listeners(this, type, true);
+    };
+    EventEmitter2.prototype.rawListeners = function rawListeners(type) {
+      return _listeners(this, type, false);
+    };
+    EventEmitter2.listenerCount = function(emitter, type) {
+      if (typeof emitter.listenerCount === "function") {
+        return emitter.listenerCount(type);
+      } else {
+        return listenerCount.call(emitter, type);
+      }
+    };
+    EventEmitter2.prototype.listenerCount = listenerCount;
+    function listenerCount(type) {
+      var events = this._events;
+      if (events !== void 0) {
+        var evlistener = events[type];
+        if (typeof evlistener === "function") {
+          return 1;
+        } else if (evlistener !== void 0) {
+          return evlistener.length;
+        }
+      }
+      return 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+    };
+    function arrayClone(arr, n) {
+      var copy = new Array(n);
+      for (var i = 0; i < n; ++i)
+        copy[i] = arr[i];
+      return copy;
+    }
+    function spliceOne(list, index) {
+      for (; index + 1 < list.length; index++)
+        list[index] = list[index + 1];
+      list.pop();
+    }
+    function unwrapListeners(arr) {
+      var ret = new Array(arr.length);
+      for (var i = 0; i < ret.length; ++i) {
+        ret[i] = arr[i].listener || arr[i];
+      }
+      return ret;
+    }
+    function once(emitter, name) {
+      return new Promise(function(resolve, reject) {
+        function errorListener(err) {
+          emitter.removeListener(name, resolver);
+          reject(err);
+        }
+        function resolver() {
+          if (typeof emitter.removeListener === "function") {
+            emitter.removeListener("error", errorListener);
+          }
+          resolve([].slice.call(arguments));
+        }
+        ;
+        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+        if (name !== "error") {
+          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+        }
+      });
+    }
+    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+      if (typeof emitter.on === "function") {
+        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+      }
+    }
+    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+      if (typeof emitter.on === "function") {
+        if (flags.once) {
+          emitter.once(name, listener);
+        } else {
+          emitter.on(name, listener);
+        }
+      } else if (typeof emitter.addEventListener === "function") {
+        emitter.addEventListener(name, function wrapListener(arg) {
+          if (flags.once) {
+            emitter.removeEventListener(name, wrapListener);
+          }
+          listener(arg);
+        });
+      } else {
+        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+      }
+    }
+  }
+});
+
+// src/node/events.ts
+var import_events = __toESM(require_events(), 1);
+function checkEvent(event) {
+  if (typeof event !== "string" && typeof event !== "symbol") throw new TypeError("Event names must be strings or symbols.");
+}
+function checkListener(listener) {
+  if (typeof listener !== "function") throw new TypeError("Event listeners must be functions.");
+}
+var EventEmitter = class {
+  #emitter = new import_events.default();
+  #registrations = /* @__PURE__ */ new Map();
+  #remove(event, registration) {
+    const entries = this.#registrations.get(event);
+    if (!entries) return;
+    const index = entries.indexOf(registration);
+    if (index !== -1) entries.splice(index, 1);
+    if (!entries.length) this.#registrations.delete(event);
+  }
+  #add(event, listener, once) {
+    checkEvent(event);
+    checkListener(listener);
+    const registration = {
+      listener,
+      invoke: (...args) => {
+        if (once) this.#remove(event, registration);
+        listener.apply(this, args);
+      }
+    };
+    const entries = this.#registrations.get(event) ?? [];
+    entries.push(registration);
+    this.#registrations.set(event, entries);
+    try {
+      if (once) this.#emitter.once(event, registration.invoke);
+      else this.#emitter.on(event, registration.invoke);
+    } catch (error) {
+      this.#remove(event, registration);
+      throw error;
+    }
+    return this;
+  }
+  on(event, listener) {
+    return this.#add(event, listener, false);
+  }
+  once(event, listener) {
+    return this.#add(event, listener, true);
+  }
+  off(event, listener) {
+    checkEvent(event);
+    checkListener(listener);
+    const entries = this.#registrations.get(event);
+    let registration;
+    if (entries) for (let index = entries.length - 1; index >= 0; index--) {
+      if (entries[index].listener === listener) {
+        registration = entries[index];
+        break;
+      }
+    }
+    if (registration) {
+      this.#remove(event, registration);
+      this.#emitter.off(event, registration.invoke);
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    checkEvent(event);
+    return this.#emitter.emit(event, ...args);
+  }
+  removeAllListeners(event) {
+    if (event === void 0) {
+      this.#registrations.clear();
+      this.#emitter.removeAllListeners();
+    } else {
+      checkEvent(event);
+      this.#registrations.delete(event);
+      this.#emitter.removeAllListeners(event);
+    }
+    return this;
+  }
+};
+var events_default = EventEmitter;
+export {
+  EventEmitter,
+  events_default as default
+};

package/dist/node/fs/backend.d.ts

@@ -0,0 +1,8 @@
+import { type FileContext } from "./lifecycle.js";
+import type { CapabilityCall, FsMethod, FsRequest, FsResult } from "./types.js";
+export interface FsBackend {
+    invoke<M extends FsMethod>(context: FileContext, method: M, params: FsRequest<M>, observe?: (result: unknown, late: boolean) => void): Promise<FsResult<M>>;
+    abort(handle: string): Promise<boolean>;
+}
+export declare function createBackend(call: CapabilityCall): FsBackend;
+export declare function responseHandle(value: unknown): string | undefined;

package/dist/node/fs/callback-types.d.ts

@@ -0,0 +1,43 @@
+import type { Buffer } from "../buffer.js";
+import type { AppendFileOptions, DirectoryEntry, FileStats, FsError, FsPromises, MkdirOptions, ReadBufferOptions, ReadFileOptions, ReadTextOptions, ReaddirOptions, RemoveOptions, WriteFileOptions } from "./types.js";
+export type VoidCallback = (error: FsError | null) => void;
+export type ValueCallback<T> = (...args: [error: FsError, data: undefined] | [error: null, data: T]) => void;
+export type UnsupportedSync = (...args: unknown[]) => never;
+export interface CallbackFs {
+    readonly promises: FsPromises;
+    readFile(path: string, callback: ValueCallback<Buffer>): void;
+    readFile(path: string, options: ReadBufferOptions | undefined, callback: ValueCallback<Buffer>): void;
+    readFile(path: string, options: ReadTextOptions, callback: ValueCallback<string>): void;
+    readFile(path: string, options: ReadFileOptions | undefined, callback: ValueCallback<Buffer | string>): void;
+    writeFile(path: string, data: string | Uint8Array, callback: VoidCallback): void;
+    writeFile(path: string, data: string | Uint8Array, options: WriteFileOptions | undefined, callback: VoidCallback): void;
+    appendFile(path: string, data: string | Uint8Array, callback: VoidCallback): void;
+    appendFile(path: string, data: string | Uint8Array, options: AppendFileOptions | undefined, callback: VoidCallback): void;
+    readdir(path: string, callback: ValueCallback<string[]>): void;
+    readdir(path: string, options: {
+        withFileTypes?: false;
+    } | undefined, callback: ValueCallback<string[]>): void;
+    readdir(path: string, options: {
+        withFileTypes: true;
+    }, callback: ValueCallback<DirectoryEntry[]>): void;
+    readdir(path: string, options: ReaddirOptions | undefined, callback: ValueCallback<string[] | DirectoryEntry[]>): void;
+    stat(path: string, callback: ValueCallback<FileStats>): void;
+    mkdir(path: string, callback: VoidCallback): void;
+    mkdir(path: string, options: {
+        recursive?: false;
+    } | undefined, callback: VoidCallback): void;
+    mkdir(path: string, options: MkdirOptions, callback: ValueCallback<string | undefined>): void;
+    rename(from: string, to: string, callback: VoidCallback): void;
+    copyFile(from: string, to: string, callback: VoidCallback): void;
+    rm(path: string, callback: VoidCallback): void;
+    rm(path: string, options: RemoveOptions | undefined, callback: VoidCallback): void;
+    readFileSync: UnsupportedSync;
+    writeFileSync: UnsupportedSync;
+    appendFileSync: UnsupportedSync;
+    readdirSync: UnsupportedSync;
+    statSync: UnsupportedSync;
+    mkdirSync: UnsupportedSync;
+    renameSync: UnsupportedSync;
+    copyFileSync: UnsupportedSync;
+    rmSync: UnsupportedSync;
+}

package/dist/node/fs/callbacks.d.ts

@@ -0,0 +1,3 @@
+import type { FsPromises } from "./types.js";
+import type { CallbackFs } from "./callback-types.js";
+export declare function createCallbackFs(promises: FsPromises): CallbackFs;

package/dist/node/fs/client.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityCall, FsClientOptions, FsPromises } from "./types.js";
+import type { SessionInfo } from "../../protocol/wire.js";
+export declare function createFsClient(call: CapabilityCall, session: () => Promise<SessionInfo>, options?: FsClientOptions): FsPromises;

package/dist/node/fs/errors.d.ts

@@ -0,0 +1,5 @@
+import type { FsError } from "./types.js";
+export declare function invalidArgument(): never;
+export declare function checkArity(count: number, min: number, max: number): void;
+export declare function toFsError(error: unknown, syscall: string, path?: unknown, dest?: unknown): FsError;
+export declare function unsupportedSync(): never;

package/dist/node/fs/lifecycle.d.ts

@@ -0,0 +1,11 @@
+import type { SessionInfo } from "../../protocol/wire.js";
+import type { FsClientOptions } from "./types.js";
+export declare function checkSignal(signal: AbortSignal): void;
+export declare function boundedOperation<T>(action: (signal: AbortSignal) => Promise<T>, signal?: AbortSignal, timeoutMs?: number, onLate?: (value: T) => void): Promise<T>;
+export interface FileContext {
+    info: SessionInfo;
+    signal: AbortSignal;
+}
+export declare function createLifecycle(session: () => Promise<SessionInfo>, options: FsClientOptions): {
+    run<T>(action: (context: FileContext) => Promise<T>): Promise<T>;
+};

package/dist/node/fs/options.d.ts

@@ -0,0 +1,7 @@
+import { Buffer } from "../buffer.js";
+export declare function filePath(value: unknown): string;
+export declare function readEncoding(value: unknown): "utf8" | null;
+export declare function writeMode(value: unknown, append: boolean): "w" | "wx" | "a" | "ax";
+export declare function boolOptions(value: unknown, allowed: readonly string[]): Record<string, boolean>;
+export declare function snapshotData(data: unknown): Buffer;
+export declare function virtualRoot(path: string): string;