@ricsam/isolate 0.0.1 → 0.1.1

package/dist/mjs/internal/fs/index.mjs

@@ -0,0 +1,783 @@
+// src/internal/fs/index.ts
+import ivm from "isolated-vm";
+import { setupCore, clearAllInstanceState } from "../core/index.mjs";
+import { createNodeFileSystemHandler } from "./node-adapter.mjs";
+var instanceStateMap = new WeakMap;
+var nextInstanceId = 1;
+function getInstanceStateMapForContext(context) {
+  let map = instanceStateMap.get(context);
+  if (!map) {
+    map = new Map;
+    instanceStateMap.set(context, map);
+  }
+  return map;
+}
+function setupFileSystemDirectoryHandle(context, stateMap) {
+  const global = context.global;
+  global.setSync("__FileSystemDirectoryHandle_get_name", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.name ?? "";
+  }));
+  global.setSync("__FileSystemDirectoryHandle_get_path", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.path ?? "/";
+  }));
+  const getFileHandleRef = new ivm.Reference(async (instanceId, name, optionsJson) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[NotFoundError]Directory handle not found");
+    }
+    const options = JSON.parse(optionsJson);
+    const childPath = state.path === "/" ? `/${name}` : `${state.path}/${name}`;
+    try {
+      await state.handler.getFileHandle(childPath, options);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+      throw err;
+    }
+    const fileInstanceId = nextInstanceId++;
+    const fileState = {
+      instanceId: fileInstanceId,
+      path: childPath,
+      name,
+      handler: state.handler
+    };
+    stateMap.set(fileInstanceId, fileState);
+    return JSON.stringify({ instanceId: fileInstanceId });
+  });
+  global.setSync("__FileSystemDirectoryHandle_getFileHandle_ref", getFileHandleRef);
+  const getDirectoryHandleRef = new ivm.Reference(async (instanceId, name, optionsJson) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[NotFoundError]Directory handle not found");
+    }
+    const options = JSON.parse(optionsJson);
+    const childPath = state.path === "/" ? `/${name}` : `${state.path}/${name}`;
+    try {
+      await state.handler.getDirectoryHandle(childPath, options);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+      throw err;
+    }
+    const dirInstanceId = nextInstanceId++;
+    const dirState = {
+      instanceId: dirInstanceId,
+      path: childPath,
+      name,
+      handler: state.handler
+    };
+    stateMap.set(dirInstanceId, dirState);
+    return JSON.stringify({ instanceId: dirInstanceId });
+  });
+  global.setSync("__FileSystemDirectoryHandle_getDirectoryHandle_ref", getDirectoryHandleRef);
+  const removeEntryRef = new ivm.Reference(async (instanceId, name, optionsJson) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[NotFoundError]Directory handle not found");
+    }
+    const options = JSON.parse(optionsJson);
+    const childPath = state.path === "/" ? `/${name}` : `${state.path}/${name}`;
+    try {
+      await state.handler.removeEntry(childPath, options);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__FileSystemDirectoryHandle_removeEntry_ref", removeEntryRef);
+  const readDirectoryRef = new ivm.Reference(async (instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[NotFoundError]Directory handle not found");
+    }
+    try {
+      const entries = await state.handler.readDirectory(state.path);
+      const result = entries.map((entry) => {
+        const entryId = nextInstanceId++;
+        const entryPath = state.path === "/" ? `/${entry.name}` : `${state.path}/${entry.name}`;
+        if (entry.kind === "file") {
+          const fileState = {
+            instanceId: entryId,
+            path: entryPath,
+            name: entry.name,
+            handler: state.handler
+          };
+          stateMap.set(entryId, fileState);
+        } else {
+          const dirState = {
+            instanceId: entryId,
+            path: entryPath,
+            name: entry.name,
+            handler: state.handler
+          };
+          stateMap.set(entryId, dirState);
+        }
+        return {
+          name: entry.name,
+          kind: entry.kind,
+          instanceId: entryId
+        };
+      });
+      return JSON.stringify(result);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__FileSystemDirectoryHandle_readDirectory_ref", readDirectoryRef);
+  global.setSync("__FileSystemDirectoryHandle_isSameEntry", new ivm.Callback((id1, id2) => {
+    const state1 = stateMap.get(id1);
+    const state2 = stateMap.get(id2);
+    if (!state1 || !state2)
+      return false;
+    return state1.path === state2.path;
+  }));
+  const resolveRef = new ivm.Reference(async (instanceId, descendantId) => {
+    const state = stateMap.get(instanceId);
+    const descendantState = stateMap.get(descendantId);
+    if (!state || !descendantState) {
+      return "null";
+    }
+    const basePath = state.path === "/" ? "" : state.path;
+    if (!descendantState.path.startsWith(basePath + "/") && descendantState.path !== state.path) {
+      return "null";
+    }
+    const relativePath = descendantState.path.slice(basePath.length);
+    const components = relativePath.split("/").filter((c) => c.length > 0);
+    return JSON.stringify(components);
+  });
+  global.setSync("__FileSystemDirectoryHandle_resolve_ref", resolveRef);
+  const directoryHandleCode = `
+(function() {
+  const _directoryHandleInstanceIds = new WeakMap();
+
+  function __decodeError(err) {
+    if (!(err instanceof Error)) return err;
+    const match = err.message.match(/^\\[(TypeError|RangeError|NotFoundError|TypeMismatchError|InvalidModificationError|Error)\\](.*)$/);
+    if (match) {
+      if (['NotFoundError', 'TypeMismatchError', 'InvalidModificationError'].includes(match[1])) {
+        return new DOMException(match[2], match[1]);
+      }
+      const ErrorType = globalThis[match[1]] || Error;
+      return new ErrorType(match[2]);
+    }
+    return err;
+  }
+
+  class FileSystemDirectoryHandle {
+    constructor(path, name) {
+      // Internal construction from instance ID
+      if (typeof path === 'number' && name === null) {
+        _directoryHandleInstanceIds.set(this, path);
+        return;
+      }
+      const instanceId = __FileSystemDirectoryHandle_construct(path, name);
+      _directoryHandleInstanceIds.set(this, instanceId);
+    }
+
+    static _fromInstanceId(instanceId) {
+      return new FileSystemDirectoryHandle(instanceId, null);
+    }
+
+    _getInstanceId() {
+      return _directoryHandleInstanceIds.get(this);
+    }
+
+    get kind() {
+      return 'directory';
+    }
+
+    get name() {
+      return __FileSystemDirectoryHandle_get_name(this._getInstanceId());
+    }
+
+    async getFileHandle(name, options = {}) {
+      try {
+        const resultJson = await __FileSystemDirectoryHandle_getFileHandle_ref.apply(
+          undefined,
+          [this._getInstanceId(), name, JSON.stringify(options)],
+          { result: { promise: true, copy: true } }
+        );
+        const result = JSON.parse(resultJson);
+        return FileSystemFileHandle._fromInstanceId(result.instanceId);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async getDirectoryHandle(name, options = {}) {
+      try {
+        const resultJson = await __FileSystemDirectoryHandle_getDirectoryHandle_ref.apply(
+          undefined,
+          [this._getInstanceId(), name, JSON.stringify(options)],
+          { result: { promise: true, copy: true } }
+        );
+        const result = JSON.parse(resultJson);
+        return FileSystemDirectoryHandle._fromInstanceId(result.instanceId);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async removeEntry(name, options = {}) {
+      try {
+        await __FileSystemDirectoryHandle_removeEntry_ref.apply(
+          undefined,
+          [this._getInstanceId(), name, JSON.stringify(options)],
+          { result: { promise: true, copy: true } }
+        );
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async *entries() {
+      let entriesJson;
+      try {
+        entriesJson = await __FileSystemDirectoryHandle_readDirectory_ref.apply(
+          undefined,
+          [this._getInstanceId()],
+          { result: { promise: true, copy: true } }
+        );
+      } catch (err) {
+        throw __decodeError(err);
+      }
+      const entries = JSON.parse(entriesJson);
+      for (const entry of entries) {
+        if (entry.kind === 'file') {
+          yield [entry.name, FileSystemFileHandle._fromInstanceId(entry.instanceId)];
+        } else {
+          yield [entry.name, FileSystemDirectoryHandle._fromInstanceId(entry.instanceId)];
+        }
+      }
+    }
+
+    async *keys() {
+      for await (const [name] of this.entries()) {
+        yield name;
+      }
+    }
+
+    async *values() {
+      for await (const [, handle] of this.entries()) {
+        yield handle;
+      }
+    }
+
+    [Symbol.asyncIterator]() {
+      return this.entries();
+    }
+
+    async isSameEntry(other) {
+      if (!(other instanceof FileSystemDirectoryHandle)) {
+        return false;
+      }
+      return __FileSystemDirectoryHandle_isSameEntry(
+        this._getInstanceId(),
+        other._getInstanceId()
+      );
+    }
+
+    async resolve(possibleDescendant) {
+      try {
+        const resultJson = await __FileSystemDirectoryHandle_resolve_ref.apply(
+          undefined,
+          [this._getInstanceId(), possibleDescendant._getInstanceId()],
+          { result: { promise: true, copy: true } }
+        );
+        return resultJson === 'null' ? null : JSON.parse(resultJson);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+  }
+
+  globalThis.FileSystemDirectoryHandle = FileSystemDirectoryHandle;
+})();
+`;
+  context.evalSync(directoryHandleCode);
+}
+function setupFileSystemFileHandle(context, stateMap) {
+  const global = context.global;
+  global.setSync("__FileSystemFileHandle_get_name", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.name ?? "";
+  }));
+  global.setSync("__FileSystemFileHandle_get_path", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.path ?? "";
+  }));
+  const getFileRef = new ivm.Reference(async (instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[NotFoundError]File handle not found");
+    }
+    try {
+      const fileData = await state.handler.readFile(state.path);
+      return JSON.stringify({
+        name: state.name,
+        data: Array.from(fileData.data),
+        size: fileData.size,
+        lastModified: fileData.lastModified,
+        type: fileData.type
+      });
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__FileSystemFileHandle_getFile_ref", getFileRef);
+  const createWritableRef = new ivm.Reference(async (instanceId, _optionsJson) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[NotFoundError]File handle not found");
+    }
+    const streamInstanceId = nextInstanceId++;
+    const streamState = {
+      instanceId: streamInstanceId,
+      filePath: state.path,
+      position: 0,
+      buffer: [],
+      closed: false,
+      handler: state.handler
+    };
+    stateMap.set(streamInstanceId, streamState);
+    return streamInstanceId;
+  });
+  global.setSync("__FileSystemFileHandle_createWritable_ref", createWritableRef);
+  global.setSync("__FileSystemFileHandle_isSameEntry", new ivm.Callback((id1, id2) => {
+    const state1 = stateMap.get(id1);
+    const state2 = stateMap.get(id2);
+    if (!state1 || !state2)
+      return false;
+    return state1.path === state2.path;
+  }));
+  const fileHandleCode = `
+(function() {
+  const _fileHandleInstanceIds = new WeakMap();
+
+  function __decodeError(err) {
+    if (!(err instanceof Error)) return err;
+    const match = err.message.match(/^\\[(TypeError|RangeError|NotFoundError|TypeMismatchError|InvalidModificationError|Error)\\](.*)$/);
+    if (match) {
+      if (['NotFoundError', 'TypeMismatchError', 'InvalidModificationError'].includes(match[1])) {
+        return new DOMException(match[2], match[1]);
+      }
+      const ErrorType = globalThis[match[1]] || Error;
+      return new ErrorType(match[2]);
+    }
+    return err;
+  }
+
+  class FileSystemFileHandle {
+    constructor(path, name) {
+      // Internal construction from instance ID
+      if (typeof path === 'number' && name === null) {
+        _fileHandleInstanceIds.set(this, path);
+        return;
+      }
+      const instanceId = __FileSystemFileHandle_construct(path, name);
+      _fileHandleInstanceIds.set(this, instanceId);
+    }
+
+    static _fromInstanceId(instanceId) {
+      return new FileSystemFileHandle(instanceId, null);
+    }
+
+    _getInstanceId() {
+      return _fileHandleInstanceIds.get(this);
+    }
+
+    get kind() {
+      return 'file';
+    }
+
+    get name() {
+      return __FileSystemFileHandle_get_name(this._getInstanceId());
+    }
+
+    async getFile() {
+      try {
+        const metadataJson = await __FileSystemFileHandle_getFile_ref.apply(
+          undefined,
+          [this._getInstanceId()],
+          { result: { promise: true, copy: true } }
+        );
+        const metadata = JSON.parse(metadataJson);
+        // Create File object from metadata and content
+        const content = new Uint8Array(metadata.data);
+        return new File([content], metadata.name, {
+          type: metadata.type,
+          lastModified: metadata.lastModified
+        });
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async createWritable(options = {}) {
+      try {
+        const streamId = await __FileSystemFileHandle_createWritable_ref.apply(
+          undefined,
+          [this._getInstanceId(), JSON.stringify(options)],
+          { result: { promise: true, copy: true } }
+        );
+        return FileSystemWritableFileStream._fromInstanceId(streamId);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async isSameEntry(other) {
+      if (!(other instanceof FileSystemFileHandle)) {
+        return false;
+      }
+      return __FileSystemFileHandle_isSameEntry(
+        this._getInstanceId(),
+        other._getInstanceId()
+      );
+    }
+  }
+
+  globalThis.FileSystemFileHandle = FileSystemFileHandle;
+})();
+`;
+  context.evalSync(fileHandleCode);
+}
+function setupFileSystemWritableFileStream(context, stateMap) {
+  const global = context.global;
+  const writeRef = new ivm.Reference(async (instanceId, bytesJson, position) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[InvalidStateError]Stream not found");
+    }
+    if (state.closed) {
+      throw new Error("[InvalidStateError]Stream is closed");
+    }
+    const bytes = JSON.parse(bytesJson);
+    const data = new Uint8Array(bytes);
+    if (position !== null) {
+      state.position = position;
+    }
+    try {
+      await state.handler.writeFile(state.filePath, data, state.position);
+      state.position += data.length;
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__FileSystemWritableFileStream_write_ref", writeRef);
+  global.setSync("__FileSystemWritableFileStream_seek", new ivm.Callback((instanceId, position) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[InvalidStateError]Stream not found");
+    }
+    if (state.closed) {
+      throw new Error("[InvalidStateError]Stream is closed");
+    }
+    state.position = position;
+  }));
+  const truncateRef = new ivm.Reference(async (instanceId, size) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[InvalidStateError]Stream not found");
+    }
+    if (state.closed) {
+      throw new Error("[InvalidStateError]Stream is closed");
+    }
+    try {
+      await state.handler.truncateFile(state.filePath, size);
+      if (state.position > size) {
+        state.position = size;
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__FileSystemWritableFileStream_truncate_ref", truncateRef);
+  const closeRef = new ivm.Reference(async (instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[InvalidStateError]Stream not found");
+    }
+    if (state.closed) {
+      throw new Error("[InvalidStateError]Stream is already closed");
+    }
+    state.closed = true;
+  });
+  global.setSync("__FileSystemWritableFileStream_close_ref", closeRef);
+  const abortRef = new ivm.Reference(async (instanceId, _reason) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[InvalidStateError]Stream not found");
+    }
+    state.closed = true;
+    state.buffer = [];
+  });
+  global.setSync("__FileSystemWritableFileStream_abort_ref", abortRef);
+  global.setSync("__FileSystemWritableFileStream_get_locked", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state ? !state.closed : false;
+  }));
+  const writableStreamCode = `
+(function() {
+  const _writableStreamInstanceIds = new WeakMap();
+
+  function __decodeError(err) {
+    if (!(err instanceof Error)) return err;
+    const match = err.message.match(/^\\[(TypeError|RangeError|InvalidStateError|NotFoundError|Error)\\](.*)$/);
+    if (match) {
+      if (['InvalidStateError', 'NotFoundError'].includes(match[1])) {
+        return new DOMException(match[2], match[1]);
+      }
+      const ErrorType = globalThis[match[1]] || Error;
+      return new ErrorType(match[2]);
+    }
+    return err;
+  }
+
+  class FileSystemWritableFileStream {
+    constructor(instanceId) {
+      _writableStreamInstanceIds.set(this, instanceId);
+    }
+
+    static _fromInstanceId(instanceId) {
+      return new FileSystemWritableFileStream(instanceId);
+    }
+
+    _getInstanceId() {
+      return _writableStreamInstanceIds.get(this);
+    }
+
+    async write(data) {
+      try {
+        // Handle different data types
+        let writeData;
+        let position = null;
+        let type = 'write';
+
+        if (data && typeof data === 'object' && !ArrayBuffer.isView(data) &&
+            !(data instanceof Blob) && !(data instanceof ArrayBuffer) &&
+            !Array.isArray(data) && typeof data.type === 'string') {
+          // WriteParams object: { type, data, position, size }
+          type = data.type || 'write';
+          if (type === 'seek') {
+            return this.seek(data.position);
+          }
+          if (type === 'truncate') {
+            return this.truncate(data.size);
+          }
+          writeData = data.data;
+          position = data.position ?? null;
+        } else {
+          writeData = data;
+        }
+
+        // Convert data to bytes array for transfer
+        let bytes;
+        if (typeof writeData === 'string') {
+          bytes = Array.from(new TextEncoder().encode(writeData));
+        } else if (writeData instanceof Blob) {
+          const buffer = await writeData.arrayBuffer();
+          bytes = Array.from(new Uint8Array(buffer));
+        } else if (writeData instanceof ArrayBuffer) {
+          bytes = Array.from(new Uint8Array(writeData));
+        } else if (ArrayBuffer.isView(writeData)) {
+          bytes = Array.from(new Uint8Array(writeData.buffer, writeData.byteOffset, writeData.byteLength));
+        } else if (Array.isArray(writeData)) {
+          bytes = writeData;
+        } else {
+          throw new TypeError('Invalid data type for write');
+        }
+
+        await __FileSystemWritableFileStream_write_ref.apply(
+          undefined,
+          [this._getInstanceId(), JSON.stringify(bytes), position],
+          { result: { promise: true, copy: true } }
+        );
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    seek(position) {
+      try {
+        __FileSystemWritableFileStream_seek(this._getInstanceId(), position);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async truncate(size) {
+      try {
+        await __FileSystemWritableFileStream_truncate_ref.apply(
+          undefined,
+          [this._getInstanceId(), size],
+          { result: { promise: true, copy: true } }
+        );
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async close() {
+      try {
+        await __FileSystemWritableFileStream_close_ref.apply(
+          undefined,
+          [this._getInstanceId()],
+          { result: { promise: true, copy: true } }
+        );
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    async abort(reason) {
+      try {
+        await __FileSystemWritableFileStream_abort_ref.apply(
+          undefined,
+          [this._getInstanceId(), reason ? String(reason) : null],
+          { result: { promise: true, copy: true } }
+        );
+      } catch (err) {
+        throw __decodeError(err);
+      }
+    }
+
+    get locked() {
+      return __FileSystemWritableFileStream_get_locked(this._getInstanceId());
+    }
+
+    getWriter() {
+      const stream = this;
+      let released = false;
+      let closedResolve;
+      let closedReject;
+      const closedPromise = new Promise((resolve, reject) => {
+        closedResolve = resolve;
+        closedReject = reject;
+      });
+
+      return {
+        get closed() {
+          return closedPromise;
+        },
+        get desiredSize() {
+          return 1;
+        },
+        get ready() {
+          return Promise.resolve();
+        },
+        async write(chunk) {
+          if (released) {
+            return Promise.reject(new TypeError('Writer has been released'));
+          }
+          try {
+            await stream.write(chunk);
+            return Promise.resolve();
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        },
+        async close() {
+          if (released) {
+            return Promise.reject(new TypeError('Writer has been released'));
+          }
+          try {
+            await stream.close();
+            closedResolve();
+            return Promise.resolve();
+          } catch (err) {
+            closedReject(err);
+            return Promise.reject(err);
+          }
+        },
+        async abort(reason) {
+          if (released) {
+            return Promise.reject(new TypeError('Writer has been released'));
+          }
+          try {
+            await stream.abort(reason);
+            closedReject(reason || new Error('Stream aborted'));
+            return Promise.resolve();
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        },
+        releaseLock() {
+          released = true;
+        }
+      };
+    }
+  }
+
+  globalThis.FileSystemWritableFileStream = FileSystemWritableFileStream;
+})();
+`;
+  context.evalSync(writableStreamCode);
+}
+function setupGetDirectoryGlobal(context, stateMap, options) {
+  const global = context.global;
+  const getDirectoryRef = new ivm.Reference(async (path) => {
+    const handler = await options.getDirectory(path);
+    const instanceId = nextInstanceId++;
+    const state = {
+      instanceId,
+      path: "/",
+      name: path.split("/").filter(Boolean).pop() || "",
+      handler
+    };
+    stateMap.set(instanceId, state);
+    return instanceId;
+  });
+  global.setSync("__getDirectory_ref", getDirectoryRef);
+  const getDirectoryCode = `
+(function() {
+  globalThis.getDirectory = async function(path) {
+    const instanceId = await __getDirectory_ref.apply(
+      undefined,
+      [path],
+      { result: { promise: true, copy: true } }
+    );
+    return FileSystemDirectoryHandle._fromInstanceId(instanceId);
+  };
+})();
+`;
+  context.evalSync(getDirectoryCode);
+}
+async function setupFs(context, options) {
+  await setupCore(context);
+  const stateMap = getInstanceStateMapForContext(context);
+  setupFileSystemDirectoryHandle(context, stateMap);
+  setupFileSystemFileHandle(context, stateMap);
+  setupFileSystemWritableFileStream(context, stateMap);
+  setupGetDirectoryGlobal(context, stateMap, options);
+  return {
+    dispose() {
+      stateMap.clear();
+    }
+  };
+}
+export {
+  setupFs,
+  createNodeFileSystemHandler,
+  clearAllInstanceState
+};
+
+//# debugId=88FA3A7BCFD718C864756E2164756E21