@ricsam/quickjs-core 0.0.1 → 0.2.1

package/dist/cjs/scope.cjs

@@ -0,0 +1,76 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/core/src/scope.ts
+var exports_scope = {};
+__export(exports_scope, {
+  withScopeAsync: () => withScopeAsync,
+  withScope: () => withScope
+});
+module.exports = __toCommonJS(exports_scope);
+function createScope() {
+  const handles = [];
+  return {
+    manage(handle) {
+      handles.push(handle);
+      return handle;
+    },
+    get handles() {
+      return handles;
+    }
+  };
+}
+function disposeScope(scope) {
+  const handles = scope.handles;
+  for (let i = handles.length - 1;i >= 0; i--) {
+    const handle = handles[i];
+    if (handle && handle.alive) {
+      handle.dispose();
+    }
+  }
+}
+function withScope(_context, fn) {
+  const scope = createScope();
+  try {
+    return fn(scope);
+  } finally {
+    disposeScope(scope);
+  }
+}
+async function withScopeAsync(_context, fn) {
+  const scope = createScope();
+  try {
+    return await fn(scope);
+  } finally {
+    disposeScope(scope);
+  }
+}
+})
+
+//# debugId=C97AB5B520552F3B64756E2164756E21

package/dist/cjs/scope.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/scope.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { Scope } from \"./types.ts\";\n\n/**\n * Create a new scope for tracking handles\n */\nfunction createScope(): Scope {\n  const handles: QuickJSHandle[] = [];\n\n  return {\n    manage<T extends QuickJSHandle>(handle: T): T {\n      handles.push(handle);\n      return handle;\n    },\n    get handles() {\n      return handles as readonly QuickJSHandle[];\n    },\n  };\n}\n\n/**\n * Dispose all handles in a scope (in reverse order)\n */\nfunction disposeScope(scope: Scope): void {\n  const handles = scope.handles;\n  for (let i = handles.length - 1; i >= 0; i--) {\n    const handle = handles[i];\n    if (handle && handle.alive) {\n      handle.dispose();\n    }\n  }\n}\n\n/**\n * Execute a function with automatic handle cleanup\n *\n * @example\n * const result = withScope(context, (scope) => {\n *   const obj = scope.manage(context.newObject());\n *   const str = scope.manage(context.newString(\"hello\"));\n *   context.setProp(obj, \"message\", str);\n *   return context.dump(obj);\n * });\n */\nexport function withScope<T>(\n  _context: QuickJSContext,\n  fn: (scope: Scope) => T\n): T {\n  const scope = createScope();\n  try {\n    return fn(scope);\n  } finally {\n    disposeScope(scope);\n  }\n}\n\n/**\n * Async version of withScope for promise-based operations\n */\nexport async function withScopeAsync<T>(\n  _context: QuickJSContext,\n  fn: (scope: Scope) => Promise<T>\n): Promise<T> {\n  const scope = createScope();\n  try {\n    return await fn(scope);\n  } finally {\n    disposeScope(scope);\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,WAAW,GAAU;AAAA,EAC5B,MAAM,UAA2B,CAAC;AAAA,EAElC,OAAO;AAAA,IACL,MAA+B,CAAC,QAAc;AAAA,MAC5C,QAAQ,KAAK,MAAM;AAAA,MACnB,OAAO;AAAA;AAAA,QAEL,OAAO,GAAG;AAAA,MACZ,OAAO;AAAA;AAAA,EAEX;AAAA;AAMF,SAAS,YAAY,CAAC,OAAoB;AAAA,EACxC,MAAM,UAAU,MAAM;AAAA,EACtB,SAAS,IAAI,QAAQ,SAAS,EAAG,KAAK,GAAG,KAAK;AAAA,IAC5C,MAAM,SAAS,QAAQ;AAAA,IACvB,IAAI,UAAU,OAAO,OAAO;AAAA,MAC1B,OAAO,QAAQ;AAAA,IACjB;AAAA,EACF;AAAA;AAcK,SAAS,SAAY,CAC1B,UACA,IACG;AAAA,EACH,MAAM,QAAQ,YAAY;AAAA,EAC1B,IAAI;AAAA,IACF,OAAO,GAAG,KAAK;AAAA,YACf;AAAA,IACA,aAAa,KAAK;AAAA;AAAA;AAOtB,eAAsB,cAAiB,CACrC,UACA,IACY;AAAA,EACZ,MAAM,QAAQ,YAAY;AAAA,EAC1B,IAAI;AAAA,IACF,OAAO,MAAM,GAAG,KAAK;AAAA,YACrB;AAAA,IACA,aAAa,KAAK;AAAA;AAAA;",
+  "debugId": "C97AB5B520552F3B64756E2164756E21",
+  "names": []
+}

package/dist/cjs/transform-stream.cjs

@@ -0,0 +1,152 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/core/src/streams/transform-stream.ts
+var exports_transform_stream = {};
+__export(exports_transform_stream, {
+  createTransformStreamClass: () => createTransformStreamClass
+});
+module.exports = __toCommonJS(exports_transform_stream);
+var import_class_builder = require("../class-builder.ts");
+function createTransformStreamClass(context, stateMap) {
+  return import_class_builder.defineClass(context, stateMap, {
+    name: "TransformStream",
+    construct: (args) => {
+      const transformer = args[0];
+      const readableQueue = [];
+      let readableCloseRequested = false;
+      let readableClosed = false;
+      let readableErrored = false;
+      let readableErrorValue = undefined;
+      const controller = {
+        enqueue(chunk) {
+          if (readableCloseRequested || readableClosed) {
+            throw new TypeError("Readable side is closed");
+          }
+          readableQueue.push(chunk);
+        },
+        error(e) {
+          readableErrored = true;
+          readableErrorValue = e;
+        },
+        terminate() {
+          readableCloseRequested = true;
+        },
+        get desiredSize() {
+          if (readableErrored)
+            return null;
+          if (readableCloseRequested)
+            return 0;
+          return 1 - readableQueue.length;
+        }
+      };
+      const readableState = {
+        locked: false,
+        reader: null,
+        queue: readableQueue,
+        closeRequested: readableCloseRequested,
+        closed: readableClosed,
+        errored: readableErrored,
+        errorValue: readableErrorValue,
+        started: true,
+        controller: {
+          enqueue: controller.enqueue,
+          close: controller.terminate,
+          error: controller.error,
+          desiredSize: 1
+        }
+      };
+      const writableState = {
+        locked: false,
+        writer: null,
+        closed: false,
+        errored: false,
+        errorValue: undefined,
+        closeRequested: false,
+        writeRequests: [],
+        inFlightWriteRequest: null,
+        started: true,
+        controller: {
+          error: controller.error
+        },
+        sink: {
+          write: async (chunk) => {
+            if (transformer?.transform) {
+              await transformer.transform(chunk, controller);
+            } else {
+              controller.enqueue(chunk);
+            }
+          },
+          close: async () => {
+            if (transformer?.flush) {
+              await transformer.flush(controller);
+            }
+            controller.terminate();
+          }
+        }
+      };
+      const state = {
+        readable: readableState,
+        writable: writableState,
+        transformer,
+        controller,
+        backpressure: false,
+        backpressureChangePromise: null
+      };
+      if (transformer?.start) {
+        try {
+          const startResult = transformer.start(controller);
+          if (startResult instanceof Promise) {
+            startResult.catch((e) => {
+              controller.error(e);
+            });
+          }
+        } catch (e) {
+          controller.error(e);
+        }
+      }
+      return state;
+    },
+    properties: {
+      readable: {
+        get() {
+          return this.readable;
+        }
+      },
+      writable: {
+        get() {
+          return this.writable;
+        }
+      }
+    }
+  });
+}
+})
+
+//# debugId=C4B9DC13F7F7B17D64756E2164756E21

package/dist/cjs/transform-stream.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/streams/transform-stream.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { StateMap } from \"../types.ts\";\nimport { defineClass } from \"../class-builder.ts\";\nimport { marshal } from \"../marshal.ts\";\nimport { unmarshal } from \"../unmarshal.ts\";\n\ninterface TransformStreamController {\n  enqueue(chunk: unknown): void;\n  error(e: unknown): void;\n  terminate(): void;\n  desiredSize: number | null;\n}\n\ninterface TransformStreamInternalState {\n  readable: object; // ReadableStream internal state\n  writable: object; // WritableStream internal state\n  transformer?: {\n    start?: (controller: TransformStreamController) => void | Promise<void>;\n    transform?: (chunk: unknown, controller: TransformStreamController) => void | Promise<void>;\n    flush?: (controller: TransformStreamController) => void | Promise<void>;\n  };\n  controller: TransformStreamController;\n  backpressure: boolean;\n  backpressureChangePromise: {\n    resolve: () => void;\n    promise: Promise<void>;\n  } | null;\n}\n\n/**\n * Create the TransformStream class\n */\nexport function createTransformStreamClass(\n  context: QuickJSContext,\n  stateMap: StateMap\n): QuickJSHandle {\n  return defineClass<TransformStreamInternalState>(context, stateMap, {\n    name: \"TransformStream\",\n    construct: (args) => {\n      const transformer = args[0] as {\n        start?: (controller: TransformStreamController) => void | Promise<void>;\n        transform?: (chunk: unknown, controller: TransformStreamController) => void | Promise<void>;\n        flush?: (controller: TransformStreamController) => void | Promise<void>;\n      } | undefined;\n\n      // Queue for the readable side\n      const readableQueue: unknown[] = [];\n      let readableCloseRequested = false;\n      let readableClosed = false;\n      let readableErrored = false;\n      let readableErrorValue: unknown = undefined;\n\n      // Create controller\n      const controller: TransformStreamController = {\n        enqueue(chunk: unknown) {\n          if (readableCloseRequested || readableClosed) {\n            throw new TypeError(\"Readable side is closed\");\n          }\n          readableQueue.push(chunk);\n        },\n        error(e: unknown) {\n          readableErrored = true;\n          readableErrorValue = e;\n        },\n        terminate() {\n          readableCloseRequested = true;\n        },\n        get desiredSize() {\n          if (readableErrored) return null;\n          if (readableCloseRequested) return 0;\n          return 1 - readableQueue.length;\n        },\n      };\n\n      // Create readable side state\n      const readableState = {\n        locked: false,\n        reader: null,\n        queue: readableQueue,\n        closeRequested: readableCloseRequested,\n        closed: readableClosed,\n        errored: readableErrored,\n        errorValue: readableErrorValue,\n        started: true,\n        controller: {\n          enqueue: controller.enqueue,\n          close: controller.terminate,\n          error: controller.error,\n          desiredSize: 1,\n        },\n      };\n\n      // Create writable side state\n      const writableState = {\n        locked: false,\n        writer: null,\n        closed: false,\n        errored: false,\n        errorValue: undefined,\n        closeRequested: false,\n        writeRequests: [],\n        inFlightWriteRequest: null,\n        started: true,\n        controller: {\n          error: controller.error,\n        },\n        sink: {\n          write: async (chunk: unknown) => {\n            if (transformer?.transform) {\n              await transformer.transform(chunk, controller);\n            } else {\n              // Default identity transform\n              controller.enqueue(chunk);\n            }\n          },\n          close: async () => {\n            if (transformer?.flush) {\n              await transformer.flush(controller);\n            }\n            controller.terminate();\n          },\n        },\n      };\n\n      const state: TransformStreamInternalState = {\n        readable: readableState,\n        writable: writableState,\n        transformer,\n        controller,\n        backpressure: false,\n        backpressureChangePromise: null,\n      };\n\n      // Call start if provided\n      if (transformer?.start) {\n        try {\n          const startResult = transformer.start(controller);\n          if (startResult instanceof Promise) {\n            startResult.catch((e) => {\n              controller.error(e);\n            });\n          }\n        } catch (e) {\n          controller.error(e);\n        }\n      }\n\n      return state;\n    },\n    properties: {\n      readable: {\n        get(this: TransformStreamInternalState) {\n          // Return the readable state - will be wrapped by the stream class\n          return this.readable;\n        },\n      },\n      writable: {\n        get(this: TransformStreamInternalState) {\n          // Return the writable state - will be wrapped by the stream class\n          return this.writable;\n        },\n      },\n    },\n  });\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "C4B9DC13F7F7B17D64756E2164756E21",
+  "names": []
+}

package/dist/cjs/types.cjs

@@ -0,0 +1,39 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/core/src/types.ts
+var exports_types = {};
+__export(exports_types, {
+  INTERNAL_STATE: () => INTERNAL_STATE
+});
+module.exports = __toCommonJS(exports_types);
+var INTERNAL_STATE = Symbol("INTERNAL_STATE");
+})
+
+//# debugId=1449C2F7927C25D664756E2164756E21

package/dist/cjs/types.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/types.ts"],
+  "sourcesContent": [
+    "import type {\n  QuickJSContext,\n  QuickJSHandle,\n  QuickJSRuntime,\n} from \"quickjs-emscripten\";\n\nexport type { QuickJSContext, QuickJSHandle, QuickJSRuntime };\n\n/**\n * A scope for automatic handle cleanup\n */\nexport interface Scope {\n  /** Track a handle for cleanup when scope ends */\n  manage<T extends QuickJSHandle>(handle: T): T;\n\n  /** Get all managed handles */\n  readonly handles: readonly QuickJSHandle[];\n}\n\n/**\n * Options for marshalling values\n */\nexport interface MarshalOptions {\n  /** Maximum depth for nested objects (default: 10) */\n  maxDepth?: number;\n\n  /** Custom marshaller for specific types */\n  custom?: (value: unknown, context: QuickJSContext) => QuickJSHandle | undefined;\n}\n\n/**\n * Options for unmarshalling values\n */\nexport interface UnmarshalOptions {\n  /** Maximum depth for nested objects (default: 10) */\n  maxDepth?: number;\n\n  /** Custom unmarshaller for specific handles */\n  custom?: (handle: QuickJSHandle, context: QuickJSContext) => unknown | undefined;\n}\n\n/**\n * Property descriptor for class builder\n */\nexport interface PropertyDescriptor<TState = unknown> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  get?: (this: TState) => any;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  set?: (this: TState, value: any) => void;\n  value?: unknown;\n  writable?: boolean;\n  enumerable?: boolean;\n  configurable?: boolean;\n}\n\n/**\n * Options for defining a class\n */\nexport interface ClassDefinition<TState extends object = object> {\n  /** Class name */\n  name: string;\n\n  /** Constructor function - receives unmarshalled args, returns internal state */\n  construct?: (args: unknown[]) => TState;\n\n  /** Prototype methods */\n  methods?: Record<string, (this: TState, ...args: unknown[]) => unknown>;\n\n  /** Prototype getters/setters */\n  properties?: Record<string, PropertyDescriptor<TState>>;\n\n  /** Static methods */\n  staticMethods?: Record<string, (...args: unknown[]) => unknown>;\n\n  /** Static properties */\n  staticProperties?: Record<string, unknown>;\n\n  /** Parent class handle (for inheritance) */\n  extends?: QuickJSHandle;\n}\n\n/**\n * Symbol used to store internal state on QuickJS class instances\n */\nexport const INTERNAL_STATE: unique symbol = Symbol(\"INTERNAL_STATE\");\n\n/**\n * Map to store internal state for QuickJS object handles\n */\nexport type StateMap = WeakMap<QuickJSHandle, object>;\n\n/**\n * Options for setting up core APIs\n */\nexport interface SetupCoreOptions {\n  /** Existing state map to use (creates new one if not provided) */\n  stateMap?: StateMap;\n}\n\n/**\n * Handle returned from setupCore\n */\nexport interface CoreHandle {\n  /** State map containing internal states */\n  readonly stateMap: StateMap;\n\n  /** Dispose all handles */\n  dispose(): void;\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFO,IAAM,iBAAgC,OAAO,gBAAgB;",
+  "debugId": "1449C2F7927C25D664756E2164756E21",
+  "names": []
+}

package/dist/cjs/unmarshal.cjs

@@ -0,0 +1,254 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/core/src/unmarshal.ts
+var exports_unmarshal = {};
+__export(exports_unmarshal, {
+  unmarshal: () => unmarshal,
+  cleanupUnmarshaledHandles: () => cleanupUnmarshaledHandles
+});
+module.exports = __toCommonJS(exports_unmarshal);
+var import_marshal = require("./marshal.ts");
+var contextDupedHandles = new WeakMap;
+function getDupedHandles(context) {
+  let handles = contextDupedHandles.get(context);
+  if (!handles) {
+    handles = new Set;
+    contextDupedHandles.set(context, handles);
+  }
+  return handles;
+}
+function cleanupUnmarshaledHandles(context) {
+  const handles = contextDupedHandles.get(context);
+  if (handles) {
+    for (const handle of handles) {
+      try {
+        handle.dispose();
+      } catch {}
+    }
+    handles.clear();
+    contextDupedHandles.delete(context);
+  }
+}
+function unmarshal(context, handle, options = {}) {
+  const maxDepth = options.maxDepth ?? 10;
+  const seen = new WeakMap;
+  function unmarshalValue(h, depth) {
+    if (depth > maxDepth) {
+      throw new Error(`Maximum unmarshalling depth of ${maxDepth} exceeded`);
+    }
+    if (options.custom) {
+      const customResult = options.custom(h, context);
+      if (customResult !== undefined) {
+        return customResult;
+      }
+    }
+    const type = context.typeof(h);
+    if (type === "undefined") {
+      return;
+    }
+    const dumpedValue = context.dump(h);
+    if (dumpedValue === null) {
+      return null;
+    }
+    if (type === "boolean") {
+      return dumpedValue;
+    }
+    if (type === "number") {
+      return dumpedValue;
+    }
+    if (type === "string") {
+      return dumpedValue;
+    }
+    if (typeof dumpedValue === "bigint") {
+      return dumpedValue;
+    }
+    if (type === "function") {
+      const fnHandle = h.dup();
+      getDupedHandles(context).add(fnHandle);
+      const wrapper = (...args) => {
+        const argHandles = args.map((arg) => import_marshal.marshal(context, arg));
+        try {
+          const result = context.callFunction(fnHandle, context.undefined, ...argHandles);
+          if (result.error) {
+            const errorValue = context.dump(result.error);
+            result.error.dispose();
+            throw new Error(typeof errorValue === "object" && errorValue !== null ? errorValue.message || String(errorValue) : String(errorValue));
+          }
+          const value = unmarshalValue(result.value, depth + 1);
+          result.value.dispose();
+          return value;
+        } finally {
+          for (const argHandle of argHandles) {
+            argHandle.dispose();
+          }
+        }
+      };
+      wrapper.__dispose__ = () => {
+        fnHandle.dispose();
+      };
+      return wrapper;
+    }
+    if (type === "object") {
+      if (seen.has(h)) {
+        return seen.get(h);
+      }
+      const lengthHandle = context.getProp(h, "length");
+      const lengthType = context.typeof(lengthHandle);
+      lengthHandle.dispose();
+      if (lengthType === "number") {
+        const arrayIsArray = context.getProp(context.global, "Array");
+        const isArrayFn = context.getProp(arrayIsArray, "isArray");
+        const isArrayResult = context.callFunction(isArrayFn, context.undefined, h);
+        arrayIsArray.dispose();
+        isArrayFn.dispose();
+        let isArray = false;
+        if (!isArrayResult.error) {
+          isArray = context.dump(isArrayResult.value) === true;
+          isArrayResult.value.dispose();
+        } else {
+          isArrayResult.error.dispose();
+        }
+        if (isArray) {
+          const arr = [];
+          seen.set(h, arr);
+          const len = context.getNumber(context.getProp(h, "length"));
+          const lenHandle = context.getProp(h, "length");
+          const length = context.getNumber(lenHandle);
+          lenHandle.dispose();
+          for (let i = 0;i < length; i++) {
+            const elementHandle = context.getProp(h, i);
+            arr[i] = unmarshalValue(elementHandle, depth + 1);
+            elementHandle.dispose();
+          }
+          return arr;
+        }
+      }
+      const dateConstructor = context.getProp(context.global, "Date");
+      const isDateResult = context.evalCode(`(function(obj, Date) { return obj instanceof Date; })`);
+      if (!isDateResult.error) {
+        const checkResult = context.callFunction(isDateResult.value, context.undefined, h, dateConstructor);
+        isDateResult.value.dispose();
+        if (!checkResult.error && context.dump(checkResult.value) === true) {
+          checkResult.value.dispose();
+          dateConstructor.dispose();
+          const getTimeHandle = context.getProp(h, "getTime");
+          const timeResult = context.callFunction(getTimeHandle, h);
+          getTimeHandle.dispose();
+          if (!timeResult.error) {
+            const timestamp = context.getNumber(timeResult.value);
+            timeResult.value.dispose();
+            return new Date(timestamp);
+          }
+          if (timeResult.error)
+            timeResult.error.dispose();
+        }
+        if (checkResult.error)
+          checkResult.error.dispose();
+        else if (checkResult.value)
+          checkResult.value.dispose();
+      } else {
+        isDateResult.error.dispose();
+      }
+      dateConstructor.dispose();
+      const uint8ArrayConstructor = context.getProp(context.global, "Uint8Array");
+      const isUint8ArrayResult = context.evalCode(`(function(obj, U8) { return obj instanceof U8; })`);
+      if (!isUint8ArrayResult.error) {
+        const checkResult = context.callFunction(isUint8ArrayResult.value, context.undefined, h, uint8ArrayConstructor);
+        isUint8ArrayResult.value.dispose();
+        if (!checkResult.error && context.dump(checkResult.value) === true) {
+          checkResult.value.dispose();
+          uint8ArrayConstructor.dispose();
+          const arrayBuffer = context.getArrayBuffer(h);
+          if (arrayBuffer) {
+            return new Uint8Array(arrayBuffer.value);
+          }
+        } else {
+          if (checkResult.error)
+            checkResult.error.dispose();
+          else
+            checkResult.value.dispose();
+          uint8ArrayConstructor.dispose();
+        }
+      } else {
+        isUint8ArrayResult.error.dispose();
+        uint8ArrayConstructor.dispose();
+      }
+      const arrayBufferConstructor = context.getProp(context.global, "ArrayBuffer");
+      const isArrayBufferResult = context.evalCode(`(function(obj, AB) { return obj instanceof AB; })`);
+      if (!isArrayBufferResult.error) {
+        const checkResult = context.callFunction(isArrayBufferResult.value, context.undefined, h, arrayBufferConstructor);
+        isArrayBufferResult.value.dispose();
+        if (!checkResult.error && context.dump(checkResult.value) === true) {
+          checkResult.value.dispose();
+          arrayBufferConstructor.dispose();
+          const arrayBuffer = context.getArrayBuffer(h);
+          if (arrayBuffer) {
+            return arrayBuffer.value.slice(0);
+          }
+        } else {
+          if (checkResult.error)
+            checkResult.error.dispose();
+          else
+            checkResult.value.dispose();
+          arrayBufferConstructor.dispose();
+        }
+      } else {
+        isArrayBufferResult.error.dispose();
+        arrayBufferConstructor.dispose();
+      }
+      const obj = {};
+      seen.set(h, obj);
+      const keysResult = context.evalCode(`(function(obj) { return Object.keys(obj); })`);
+      if (!keysResult.error) {
+        const keysArrayHandle = context.callFunction(keysResult.value, context.undefined, h);
+        keysResult.value.dispose();
+        if (!keysArrayHandle.error) {
+          const keysArray = unmarshalValue(keysArrayHandle.value, depth + 1);
+          keysArrayHandle.value.dispose();
+          for (const key of keysArray) {
+            const propHandle = context.getProp(h, key);
+            obj[key] = unmarshalValue(propHandle, depth + 1);
+            propHandle.dispose();
+          }
+        } else {
+          keysArrayHandle.error.dispose();
+        }
+      } else {
+        keysResult.error.dispose();
+      }
+      return obj;
+    }
+    return dumpedValue;
+  }
+  return unmarshalValue(handle, 0);
+}
+})
+
+//# debugId=B57FBFC1AF15EE0664756E2164756E21

package/dist/cjs/unmarshal.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/unmarshal.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { UnmarshalOptions } from \"./types.ts\";\nimport { marshal } from \"./marshal.ts\";\n\n// Track duped handles per context so they can be cleaned up\nconst contextDupedHandles = new WeakMap<QuickJSContext, Set<QuickJSHandle>>();\n\n/**\n * Get or create the set of duped handles for a context\n */\nfunction getDupedHandles(context: QuickJSContext): Set<QuickJSHandle> {\n  let handles = contextDupedHandles.get(context);\n  if (!handles) {\n    handles = new Set();\n    contextDupedHandles.set(context, handles);\n  }\n  return handles;\n}\n\n/**\n * Clean up all duped handles for a context\n * Should be called before disposing the context\n */\nexport function cleanupUnmarshaledHandles(context: QuickJSContext): void {\n  const handles = contextDupedHandles.get(context);\n  if (handles) {\n    for (const handle of handles) {\n      try {\n        handle.dispose();\n      } catch {\n        // Handle may already be disposed\n      }\n    }\n    handles.clear();\n    contextDupedHandles.delete(context);\n  }\n}\n\n/**\n * Unmarshal a QuickJS handle to a JavaScript value\n *\n * @example\n * const value = unmarshal(context, handle);\n */\nexport function unmarshal(\n  context: QuickJSContext,\n  handle: QuickJSHandle,\n  options: UnmarshalOptions = {}\n): unknown {\n  const maxDepth = options.maxDepth ?? 10;\n  const seen = new WeakMap<QuickJSHandle, object>();\n\n  function unmarshalValue(h: QuickJSHandle, depth: number): unknown {\n    if (depth > maxDepth) {\n      throw new Error(`Maximum unmarshalling depth of ${maxDepth} exceeded`);\n    }\n\n    // Try custom unmarshaller first\n    if (options.custom) {\n      const customResult = options.custom(h, context);\n      if (customResult !== undefined) {\n        return customResult;\n      }\n    }\n\n    const type = context.typeof(h);\n\n    // Handle primitives\n    if (type === \"undefined\") {\n      return undefined;\n    }\n\n    // Check for null (typeof returns \"object\" for null)\n    const dumpedValue = context.dump(h);\n    if (dumpedValue === null) {\n      return null;\n    }\n\n    if (type === \"boolean\") {\n      return dumpedValue as boolean;\n    }\n    if (type === \"number\") {\n      return dumpedValue as number;\n    }\n    if (type === \"string\") {\n      return dumpedValue as string;\n    }\n\n    // Handle bigint\n    if (typeof dumpedValue === \"bigint\") {\n      return dumpedValue;\n    }\n\n    // Handle functions - return a wrapper that calls back into QuickJS\n    if (type === \"function\") {\n      // Dup the handle so it stays alive after unmarshalling\n      // This is necessary because the caller may dispose the original handle\n      const fnHandle = h.dup();\n      // Track the duped handle for cleanup\n      getDupedHandles(context).add(fnHandle);\n      const wrapper = (...args: unknown[]) => {\n        const argHandles = args.map((arg) => marshal(context, arg));\n        try {\n          const result = context.callFunction(fnHandle, context.undefined, ...argHandles);\n          if (result.error) {\n            const errorValue = context.dump(result.error);\n            result.error.dispose();\n            throw new Error(\n              typeof errorValue === \"object\" && errorValue !== null\n                ? (errorValue as { message?: string }).message || String(errorValue)\n                : String(errorValue)\n            );\n          }\n          const value = unmarshalValue(result.value, depth + 1);\n          result.value.dispose();\n          return value;\n        } finally {\n          for (const argHandle of argHandles) {\n            argHandle.dispose();\n          }\n        }\n      };\n      // Attach a dispose method to clean up the handle when the function is no longer needed\n      (wrapper as unknown as { __dispose__: () => void }).__dispose__ = () => {\n        fnHandle.dispose();\n      };\n      return wrapper;\n    }\n\n    // Handle objects\n    if (type === \"object\") {\n      // Check for circular reference\n      if (seen.has(h)) {\n        return seen.get(h);\n      }\n\n      // Check if it's an array\n      const lengthHandle = context.getProp(h, \"length\");\n      const lengthType = context.typeof(lengthHandle);\n      lengthHandle.dispose();\n\n      if (lengthType === \"number\") {\n        // Check for Array by looking for Array.isArray\n        const arrayIsArray = context.getProp(context.global, \"Array\");\n        const isArrayFn = context.getProp(arrayIsArray, \"isArray\");\n        const isArrayResult = context.callFunction(isArrayFn, context.undefined, h);\n        arrayIsArray.dispose();\n        isArrayFn.dispose();\n\n        let isArray = false;\n        if (!isArrayResult.error) {\n          isArray = context.dump(isArrayResult.value) === true;\n          isArrayResult.value.dispose();\n        } else {\n          isArrayResult.error.dispose();\n        }\n\n        if (isArray) {\n          const arr: unknown[] = [];\n          seen.set(h, arr);\n\n          const len = context.getNumber(context.getProp(h, \"length\"));\n          const lenHandle = context.getProp(h, \"length\");\n          const length = context.getNumber(lenHandle);\n          lenHandle.dispose();\n\n          for (let i = 0; i < length; i++) {\n            const elementHandle = context.getProp(h, i);\n            arr[i] = unmarshalValue(elementHandle, depth + 1);\n            elementHandle.dispose();\n          }\n          return arr;\n        }\n      }\n\n      // Check if it's a Date\n      const dateConstructor = context.getProp(context.global, \"Date\");\n      const isDateResult = context.evalCode(`(function(obj, Date) { return obj instanceof Date; })`);\n      if (!isDateResult.error) {\n        const checkResult = context.callFunction(\n          isDateResult.value,\n          context.undefined,\n          h,\n          dateConstructor\n        );\n        isDateResult.value.dispose();\n\n        if (!checkResult.error && context.dump(checkResult.value) === true) {\n          checkResult.value.dispose();\n          dateConstructor.dispose();\n\n          const getTimeHandle = context.getProp(h, \"getTime\");\n          const timeResult = context.callFunction(getTimeHandle, h);\n          getTimeHandle.dispose();\n\n          if (!timeResult.error) {\n            const timestamp = context.getNumber(timeResult.value);\n            timeResult.value.dispose();\n            return new Date(timestamp);\n          }\n          if (timeResult.error) timeResult.error.dispose();\n        }\n        if (checkResult.error) checkResult.error.dispose();\n        else if (checkResult.value) checkResult.value.dispose();\n      } else {\n        isDateResult.error.dispose();\n      }\n      dateConstructor.dispose();\n\n      // Check if it's a Uint8Array\n      const uint8ArrayConstructor = context.getProp(context.global, \"Uint8Array\");\n      const isUint8ArrayResult = context.evalCode(`(function(obj, U8) { return obj instanceof U8; })`);\n      if (!isUint8ArrayResult.error) {\n        const checkResult = context.callFunction(\n          isUint8ArrayResult.value,\n          context.undefined,\n          h,\n          uint8ArrayConstructor\n        );\n        isUint8ArrayResult.value.dispose();\n\n        if (!checkResult.error && context.dump(checkResult.value) === true) {\n          checkResult.value.dispose();\n          uint8ArrayConstructor.dispose();\n\n          // Get the Uint8Array bytes\n          const arrayBuffer = context.getArrayBuffer(h);\n          if (arrayBuffer) {\n            return new Uint8Array(arrayBuffer.value);\n          }\n          // Fall through to plain object handling if getArrayBuffer fails\n        } else {\n          if (checkResult.error) checkResult.error.dispose();\n          else checkResult.value.dispose();\n          uint8ArrayConstructor.dispose();\n        }\n      } else {\n        isUint8ArrayResult.error.dispose();\n        uint8ArrayConstructor.dispose();\n      }\n\n      // Check if it's an ArrayBuffer\n      const arrayBufferConstructor = context.getProp(context.global, \"ArrayBuffer\");\n      const isArrayBufferResult = context.evalCode(`(function(obj, AB) { return obj instanceof AB; })`);\n      if (!isArrayBufferResult.error) {\n        const checkResult = context.callFunction(\n          isArrayBufferResult.value,\n          context.undefined,\n          h,\n          arrayBufferConstructor\n        );\n        isArrayBufferResult.value.dispose();\n\n        if (!checkResult.error && context.dump(checkResult.value) === true) {\n          checkResult.value.dispose();\n          arrayBufferConstructor.dispose();\n\n          // Get the ArrayBuffer bytes directly\n          const arrayBuffer = context.getArrayBuffer(h);\n          if (arrayBuffer) {\n            return arrayBuffer.value.slice(0);\n          }\n          // Fall through to plain object handling if getArrayBuffer fails\n        } else {\n          if (checkResult.error) checkResult.error.dispose();\n          else checkResult.value.dispose();\n          arrayBufferConstructor.dispose();\n        }\n      } else {\n        isArrayBufferResult.error.dispose();\n        arrayBufferConstructor.dispose();\n      }\n\n      // Plain object\n      const obj: Record<string, unknown> = {};\n      seen.set(h, obj);\n\n      // Get own enumerable properties\n      const keysResult = context.evalCode(`(function(obj) { return Object.keys(obj); })`);\n      if (!keysResult.error) {\n        const keysArrayHandle = context.callFunction(keysResult.value, context.undefined, h);\n        keysResult.value.dispose();\n\n        if (!keysArrayHandle.error) {\n          const keysArray = unmarshalValue(keysArrayHandle.value, depth + 1) as string[];\n          keysArrayHandle.value.dispose();\n\n          for (const key of keysArray) {\n            const propHandle = context.getProp(h, key);\n            obj[key] = unmarshalValue(propHandle, depth + 1);\n            propHandle.dispose();\n          }\n        } else {\n          keysArrayHandle.error.dispose();\n        }\n      } else {\n        keysResult.error.dispose();\n      }\n\n      return obj;\n    }\n\n    // Fallback to dump for unknown types\n    return dumpedValue;\n  }\n\n  return unmarshalValue(handle, 0);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "B57FBFC1AF15EE0664756E2164756E21",
+  "names": []
+}