@ricsam/isolate 0.0.1 → 0.1.1

package/dist/cjs/internal/fs/index.cjs

@@ -0,0 +1,847 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/fs/index.ts
+var exports_fs = {};
+__export(exports_fs, {
+  setupFs: () => setupFs,
+  createNodeFileSystemHandler: () => import_node_adapter.createNodeFileSystemHandler,
+  clearAllInstanceState: () => import_core.clearAllInstanceState
+});
+module.exports = __toCommonJS(exports_fs);
+var import_isolated_vm = __toESM(require("isolated-vm"));
+var import_core = require("../core/index.cjs");
+var import_node_adapter = require("./node-adapter.cjs");
+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 import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.name ?? "";
+  }));
+  global.setSync("__FileSystemDirectoryHandle_get_path", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.path ?? "/";
+  }));
+  const getFileHandleRef = new import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.name ?? "";
+  }));
+  global.setSync("__FileSystemFileHandle_get_path", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.path ?? "";
+  }));
+  const getFileRef = new import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_isolated_vm.default.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 import_core.setupCore(context);
+  const stateMap = getInstanceStateMapForContext(context);
+  setupFileSystemDirectoryHandle(context, stateMap);
+  setupFileSystemFileHandle(context, stateMap);
+  setupFileSystemWritableFileStream(context, stateMap);
+  setupGetDirectoryGlobal(context, stateMap, options);
+  return {
+    dispose() {
+      stateMap.clear();
+    }
+  };
+}
+
+//# debugId=ADBCB5895F0DF93F64756E2164756E21