@ricsam/isolate 0.0.1 → 0.1.0

package/dist/cjs/internal/crypto/index.cjs

@@ -0,0 +1,470 @@
+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)
+    });
+};
+
+// packages/isolate/src/internal/crypto/index.ts
+var exports_crypto = {};
+__export(exports_crypto, {
+  setupCrypto: () => setupCrypto
+});
+module.exports = __toCommonJS(exports_crypto);
+var import_isolated_vm = __toESM(require("isolated-vm"));
+var import_node_crypto = __toESM(require("node:crypto"));
+var cryptoKeysByContext = new WeakMap;
+var nextKeyId = 1;
+function getKeyMapForContext(context) {
+  let map = cryptoKeysByContext.get(context);
+  if (!map) {
+    map = new Map;
+    cryptoKeysByContext.set(context, map);
+  }
+  return map;
+}
+function deserializeAlgorithm(algorithm) {
+  const result = {};
+  for (const [key, value] of Object.entries(algorithm)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((k) => /^\d+$/.test(k))) {
+      const length = Object.keys(value).length;
+      const arr = new Uint8Array(length);
+      for (let i = 0;i < length; i++) {
+        arr[i] = value[String(i)] ?? 0;
+      }
+      result[key] = arr;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function setupCrypto(context) {
+  const global = context.global;
+  global.setSync("__crypto_randomUUID", new import_isolated_vm.default.Callback(() => {
+    return import_node_crypto.default.randomUUID();
+  }));
+  global.setSync("__crypto_getRandomValues", new import_isolated_vm.default.Callback((byteLength) => {
+    const buffer = Buffer.alloc(byteLength);
+    import_node_crypto.default.randomFillSync(buffer);
+    return Array.from(buffer);
+  }));
+  const keyMap = getKeyMapForContext(context);
+  const importKeyRef = new import_isolated_vm.default.Reference(async (format, keyDataJson, algorithmJson, extractable, keyUsagesJson) => {
+    const keyData = JSON.parse(keyDataJson);
+    const algorithm = JSON.parse(algorithmJson);
+    const keyUsages = JSON.parse(keyUsagesJson);
+    try {
+      let cryptoKey;
+      if (format === "raw") {
+        const importData = new Uint8Array(keyData);
+        cryptoKey = await import_node_crypto.default.webcrypto.subtle.importKey("raw", importData, algorithm, extractable, keyUsages);
+      } else if (format === "jwk") {
+        const importData = keyData;
+        cryptoKey = await import_node_crypto.default.webcrypto.subtle.importKey("jwk", importData, algorithm, extractable, keyUsages);
+      } else {
+        throw new Error(`[NotSupportedError]Unsupported key format: ${format}`);
+      }
+      const keyId = nextKeyId++;
+      keyMap.set(keyId, cryptoKey);
+      return keyId;
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`[${err.name}]${err.message}`);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__crypto_subtle_importKey_ref", importKeyRef);
+  const signRef = new import_isolated_vm.default.Reference(async (algorithmJson, keyId, dataJson) => {
+    const algorithm = JSON.parse(algorithmJson);
+    const data = new Uint8Array(JSON.parse(dataJson));
+    const cryptoKey = keyMap.get(keyId);
+    if (!cryptoKey) {
+      throw new Error("[InvalidAccessError]Key not found");
+    }
+    try {
+      const signature = await import_node_crypto.default.webcrypto.subtle.sign(algorithm, cryptoKey, data);
+      return JSON.stringify(Array.from(new Uint8Array(signature)));
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`[${err.name}]${err.message}`);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__crypto_subtle_sign_ref", signRef);
+  const verifyRef = new import_isolated_vm.default.Reference(async (algorithmJson, keyId, signatureJson, dataJson) => {
+    const algorithm = JSON.parse(algorithmJson);
+    const signature = new Uint8Array(JSON.parse(signatureJson));
+    const data = new Uint8Array(JSON.parse(dataJson));
+    const cryptoKey = keyMap.get(keyId);
+    if (!cryptoKey) {
+      throw new Error("[InvalidAccessError]Key not found");
+    }
+    try {
+      return await import_node_crypto.default.webcrypto.subtle.verify(algorithm, cryptoKey, signature, data);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`[${err.name}]${err.message}`);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__crypto_subtle_verify_ref", verifyRef);
+  const digestRef = new import_isolated_vm.default.Reference(async (algorithmJson, dataJson) => {
+    const algorithm = JSON.parse(algorithmJson);
+    const data = new Uint8Array(JSON.parse(dataJson));
+    try {
+      const hash = await import_node_crypto.default.webcrypto.subtle.digest(algorithm, data);
+      return JSON.stringify(Array.from(new Uint8Array(hash)));
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`[${err.name}]${err.message}`);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__crypto_subtle_digest_ref", digestRef);
+  const deriveBitsRef = new import_isolated_vm.default.Reference(async (algorithmJson, keyId, length) => {
+    const algorithm = deserializeAlgorithm(JSON.parse(algorithmJson));
+    const cryptoKey = keyMap.get(keyId);
+    if (!cryptoKey) {
+      throw new Error("[InvalidAccessError]Key not found");
+    }
+    try {
+      const bits = await import_node_crypto.default.webcrypto.subtle.deriveBits(algorithm, cryptoKey, length);
+      return JSON.stringify(Array.from(new Uint8Array(bits)));
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`[${err.name}]${err.message}`);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__crypto_subtle_deriveBits_ref", deriveBitsRef);
+  const deriveKeyRef = new import_isolated_vm.default.Reference(async (algorithmJson, baseKeyId, derivedKeyAlgorithmJson, extractable, keyUsagesJson) => {
+    const algorithm = deserializeAlgorithm(JSON.parse(algorithmJson));
+    const derivedKeyAlgorithm = JSON.parse(derivedKeyAlgorithmJson);
+    const keyUsages = JSON.parse(keyUsagesJson);
+    const baseKey = keyMap.get(baseKeyId);
+    if (!baseKey) {
+      throw new Error("[InvalidAccessError]Key not found");
+    }
+    try {
+      const derivedKey = await import_node_crypto.default.webcrypto.subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages);
+      const keyId = nextKeyId++;
+      keyMap.set(keyId, derivedKey);
+      return keyId;
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`[${err.name}]${err.message}`);
+      }
+      throw err;
+    }
+  });
+  global.setSync("__crypto_subtle_deriveKey_ref", deriveKeyRef);
+  const cryptoCode = `
+(function() {
+  // DOMException polyfill (Pattern #12)
+  if (typeof DOMException === 'undefined') {
+    globalThis.DOMException = class DOMException extends Error {
+      constructor(message, name) {
+        super(message);
+        this.name = name || 'DOMException';
+      }
+    };
+  }
+
+  // Helper to decode error from host
+  function __decodeError(err) {
+    if (!(err instanceof Error)) return err;
+    const match = err.message.match(/^\\[(TypeError|RangeError|NotSupportedError|InvalidAccessError|OperationError|DataError|Error)\\](.*)$/);
+    if (match) {
+      if (['NotSupportedError', 'InvalidAccessError', 'OperationError', 'DataError'].includes(match[1])) {
+        return new DOMException(match[2], match[1]);
+      }
+      const ErrorType = globalThis[match[1]] || Error;
+      return new ErrorType(match[2]);
+    }
+    return err;
+  }
+
+  // CryptoKey class to wrap key IDs
+  const _cryptoKeyIds = new WeakMap();
+
+  class CryptoKey {
+    constructor(keyId, algorithm, extractable, usages, type) {
+      _cryptoKeyIds.set(this, keyId);
+      this._algorithm = algorithm;
+      this._extractable = extractable;
+      this._usages = usages;
+      this._type = type || 'secret';
+    }
+
+    _getKeyId() {
+      return _cryptoKeyIds.get(this);
+    }
+
+    get algorithm() {
+      return this._algorithm;
+    }
+
+    get extractable() {
+      return this._extractable;
+    }
+
+    get usages() {
+      return [...this._usages];
+    }
+
+    get type() {
+      return this._type;
+    }
+  }
+
+  globalThis.CryptoKey = CryptoKey;
+
+  // Helper to convert data to byte array
+  function toByteArray(data) {
+    if (typeof data === 'string') {
+      return Array.from(new TextEncoder().encode(data));
+    }
+    if (data instanceof ArrayBuffer) {
+      return Array.from(new Uint8Array(data));
+    }
+    if (ArrayBuffer.isView(data)) {
+      return Array.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    }
+    throw new TypeError('Data must be a BufferSource');
+  }
+
+  // Normalize algorithm to object form
+  function normalizeAlgorithm(algorithm) {
+    if (typeof algorithm === 'string') {
+      return { name: algorithm };
+    }
+    return algorithm;
+  }
+
+  globalThis.crypto = {
+    randomUUID() {
+      return __crypto_randomUUID();
+    },
+
+    getRandomValues(typedArray) {
+      // Validate input is an integer TypedArray
+      if (!(typedArray instanceof Int8Array ||
+            typedArray instanceof Uint8Array ||
+            typedArray instanceof Uint8ClampedArray ||
+            typedArray instanceof Int16Array ||
+            typedArray instanceof Uint16Array ||
+            typedArray instanceof Int32Array ||
+            typedArray instanceof Uint32Array ||
+            typedArray instanceof BigInt64Array ||
+            typedArray instanceof BigUint64Array)) {
+        throw new TypeError("Argument 1 must be an integer typed array");
+      }
+
+      const byteLength = typedArray.byteLength;
+      if (byteLength > 65536) {
+        throw new DOMException(
+          "The ArrayBufferView's byte length exceeds the number of bytes of entropy available via this API (65536)",
+          "QuotaExceededError"
+        );
+      }
+
+      // Get random bytes from host
+      const bytes = __crypto_getRandomValues(byteLength);
+
+      // Copy bytes into the TypedArray
+      const view = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+      for (let i = 0; i < bytes.length; i++) {
+        view[i] = bytes[i];
+      }
+
+      return typedArray;
+    },
+
+    subtle: {
+      async importKey(format, keyData, algorithm, extractable, keyUsages) {
+        try {
+          const normalizedAlgo = normalizeAlgorithm(algorithm);
+          let keyDataJson;
+
+          if (format === 'raw') {
+            keyDataJson = JSON.stringify(toByteArray(keyData));
+          } else if (format === 'jwk') {
+            keyDataJson = JSON.stringify(keyData);
+          } else {
+            throw new DOMException('Unsupported key format: ' + format, 'NotSupportedError');
+          }
+
+          const keyId = await __crypto_subtle_importKey_ref.apply(undefined, [
+            format,
+            keyDataJson,
+            JSON.stringify(normalizedAlgo),
+            extractable,
+            JSON.stringify(keyUsages)
+          ], { result: { promise: true, copy: true } });
+
+          return new CryptoKey(keyId, normalizedAlgo, extractable, keyUsages);
+        } catch (err) {
+          throw __decodeError(err);
+        }
+      },
+
+      async sign(algorithm, key, data) {
+        try {
+          if (!(key instanceof CryptoKey)) {
+            throw new TypeError('Key must be a CryptoKey');
+          }
+          const normalizedAlgo = normalizeAlgorithm(algorithm);
+          const signatureBytesJson = await __crypto_subtle_sign_ref.apply(undefined, [
+            JSON.stringify(normalizedAlgo),
+            key._getKeyId(),
+            JSON.stringify(toByteArray(data))
+          ], { result: { promise: true, copy: true } });
+          const signatureBytes = JSON.parse(signatureBytesJson);
+          return new Uint8Array(signatureBytes).buffer;
+        } catch (err) {
+          throw __decodeError(err);
+        }
+      },
+
+      async verify(algorithm, key, signature, data) {
+        try {
+          if (!(key instanceof CryptoKey)) {
+            throw new TypeError('Key must be a CryptoKey');
+          }
+          const normalizedAlgo = normalizeAlgorithm(algorithm);
+          return await __crypto_subtle_verify_ref.apply(undefined, [
+            JSON.stringify(normalizedAlgo),
+            key._getKeyId(),
+            JSON.stringify(toByteArray(signature)),
+            JSON.stringify(toByteArray(data))
+          ], { result: { promise: true, copy: true } });
+        } catch (err) {
+          throw __decodeError(err);
+        }
+      },
+
+      async digest(algorithm, data) {
+        try {
+          const normalizedAlgo = normalizeAlgorithm(algorithm);
+          const hashBytesJson = await __crypto_subtle_digest_ref.apply(undefined, [
+            JSON.stringify(normalizedAlgo),
+            JSON.stringify(toByteArray(data))
+          ], { result: { promise: true, copy: true } });
+          const hashBytes = JSON.parse(hashBytesJson);
+          return new Uint8Array(hashBytes).buffer;
+        } catch (err) {
+          throw __decodeError(err);
+        }
+      },
+
+      async deriveBits(algorithm, baseKey, length) {
+        try {
+          if (!(baseKey instanceof CryptoKey)) {
+            throw new TypeError('Key must be a CryptoKey');
+          }
+          const normalizedAlgo = normalizeAlgorithm(algorithm);
+          const bitsBytesJson = await __crypto_subtle_deriveBits_ref.apply(undefined, [
+            JSON.stringify(normalizedAlgo),
+            baseKey._getKeyId(),
+            length
+          ], { result: { promise: true, copy: true } });
+          const bitsBytes = JSON.parse(bitsBytesJson);
+          return new Uint8Array(bitsBytes).buffer;
+        } catch (err) {
+          throw __decodeError(err);
+        }
+      },
+
+      async deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+        try {
+          if (!(baseKey instanceof CryptoKey)) {
+            throw new TypeError('Key must be a CryptoKey');
+          }
+          const normalizedAlgo = normalizeAlgorithm(algorithm);
+          const normalizedDerivedAlgo = normalizeAlgorithm(derivedKeyAlgorithm);
+          const keyId = await __crypto_subtle_deriveKey_ref.apply(undefined, [
+            JSON.stringify(normalizedAlgo),
+            baseKey._getKeyId(),
+            JSON.stringify(normalizedDerivedAlgo),
+            extractable,
+            JSON.stringify(keyUsages)
+          ], { result: { promise: true, copy: true } });
+          return new CryptoKey(keyId, normalizedDerivedAlgo, extractable, keyUsages);
+        } catch (err) {
+          throw __decodeError(err);
+        }
+      }
+    }
+  };
+})();
+`;
+  context.evalSync(cryptoCode);
+  return {
+    dispose() {
+      keyMap.clear();
+    }
+  };
+}
+
+//# debugId=41260A8CB010326964756E2164756E21

package/dist/cjs/internal/crypto/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/crypto/index.ts"],
+  "sourcesContent": [
+    "import ivm from \"isolated-vm\";\nimport crypto from \"node:crypto\";\n\nexport interface CryptoHandle {\n  dispose(): void;\n}\n\n// Host-side key storage for crypto.subtle\nconst cryptoKeysByContext = new WeakMap<ivm.Context, Map<number, crypto.webcrypto.CryptoKey>>();\nlet nextKeyId = 1;\n\nfunction getKeyMapForContext(context: ivm.Context): Map<number, crypto.webcrypto.CryptoKey> {\n  let map = cryptoKeysByContext.get(context);\n  if (!map) {\n    map = new Map();\n    cryptoKeysByContext.set(context, map);\n  }\n  return map;\n}\n\nfunction deserializeAlgorithm(algorithm: Record<string, unknown>): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(algorithm)) {\n    if (value && typeof value === 'object' && !Array.isArray(value) &&\n        Object.keys(value).every(k => /^\\d+$/.test(k))) {\n      // Convert {\"0\": n, \"1\": m, ...} back to Uint8Array\n      const length = Object.keys(value).length;\n      const arr = new Uint8Array(length);\n      for (let i = 0; i < length; i++) {\n        arr[i] = (value as Record<string, number>)[String(i)] ?? 0;\n      }\n      result[key] = arr;\n    } else {\n      result[key] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Setup Web Crypto API in an isolated-vm context\n *\n * Provides crypto.getRandomValues and crypto.randomUUID\n *\n * @example\n * const handle = await setupCrypto(context);\n * await context.eval(`\n *   const uuid = crypto.randomUUID();\n *   const array = new Uint8Array(16);\n *   crypto.getRandomValues(array);\n * `);\n */\nexport async function setupCrypto(\n  context: ivm.Context\n): Promise<CryptoHandle> {\n  const global = context.global;\n\n  // Register host callbacks\n  global.setSync(\n    \"__crypto_randomUUID\",\n    new ivm.Callback(() => {\n      return crypto.randomUUID();\n    })\n  );\n\n  global.setSync(\n    \"__crypto_getRandomValues\",\n    new ivm.Callback((byteLength: number) => {\n      const buffer = Buffer.alloc(byteLength);\n      crypto.randomFillSync(buffer);\n      return Array.from(buffer);\n    })\n  );\n\n  // Get key map for this context\n  const keyMap = getKeyMapForContext(context);\n\n  // crypto.subtle.importKey - async reference\n  const importKeyRef = new ivm.Reference(\n    async (\n      format: string,\n      keyDataJson: string,\n      algorithmJson: string,\n      extractable: boolean,\n      keyUsagesJson: string\n    ) => {\n      const keyData = JSON.parse(keyDataJson) as number[];\n      const algorithm = JSON.parse(algorithmJson);\n      const keyUsages = JSON.parse(keyUsagesJson) as crypto.webcrypto.KeyUsage[];\n\n      try {\n        let cryptoKey: crypto.webcrypto.CryptoKey;\n        if (format === \"raw\") {\n          const importData = new Uint8Array(keyData);\n          cryptoKey = await crypto.webcrypto.subtle.importKey(\n            \"raw\",\n            importData,\n            algorithm,\n            extractable,\n            keyUsages\n          );\n        } else if (format === \"jwk\") {\n          const importData = keyData as unknown as crypto.webcrypto.JsonWebKey;\n          cryptoKey = await crypto.webcrypto.subtle.importKey(\n            \"jwk\",\n            importData,\n            algorithm,\n            extractable,\n            keyUsages\n          );\n        } else {\n          throw new Error(`[NotSupportedError]Unsupported key format: ${format}`);\n        }\n\n        // Store key on host and return ID\n        const keyId = nextKeyId++;\n        keyMap.set(keyId, cryptoKey);\n        return keyId;\n      } catch (err) {\n        if (err instanceof Error) {\n          throw new Error(`[${err.name}]${err.message}`);\n        }\n        throw err;\n      }\n    }\n  );\n  global.setSync(\"__crypto_subtle_importKey_ref\", importKeyRef);\n\n  // crypto.subtle.sign - async reference\n  const signRef = new ivm.Reference(\n    async (algorithmJson: string, keyId: number, dataJson: string) => {\n      const algorithm = JSON.parse(algorithmJson);\n      const data = new Uint8Array(JSON.parse(dataJson) as number[]);\n\n      const cryptoKey = keyMap.get(keyId);\n      if (!cryptoKey) {\n        throw new Error(\"[InvalidAccessError]Key not found\");\n      }\n\n      try {\n        const signature = await crypto.webcrypto.subtle.sign(\n          algorithm,\n          cryptoKey,\n          data\n        );\n        return JSON.stringify(Array.from(new Uint8Array(signature)));\n      } catch (err) {\n        if (err instanceof Error) {\n          throw new Error(`[${err.name}]${err.message}`);\n        }\n        throw err;\n      }\n    }\n  );\n  global.setSync(\"__crypto_subtle_sign_ref\", signRef);\n\n  // crypto.subtle.verify - async reference\n  const verifyRef = new ivm.Reference(\n    async (\n      algorithmJson: string,\n      keyId: number,\n      signatureJson: string,\n      dataJson: string\n    ) => {\n      const algorithm = JSON.parse(algorithmJson);\n      const signature = new Uint8Array(JSON.parse(signatureJson) as number[]);\n      const data = new Uint8Array(JSON.parse(dataJson) as number[]);\n\n      const cryptoKey = keyMap.get(keyId);\n      if (!cryptoKey) {\n        throw new Error(\"[InvalidAccessError]Key not found\");\n      }\n\n      try {\n        return await crypto.webcrypto.subtle.verify(\n          algorithm,\n          cryptoKey,\n          signature,\n          data\n        );\n      } catch (err) {\n        if (err instanceof Error) {\n          throw new Error(`[${err.name}]${err.message}`);\n        }\n        throw err;\n      }\n    }\n  );\n  global.setSync(\"__crypto_subtle_verify_ref\", verifyRef);\n\n  // crypto.subtle.digest - async reference\n  const digestRef = new ivm.Reference(\n    async (algorithmJson: string, dataJson: string) => {\n      const algorithm = JSON.parse(algorithmJson);\n      const data = new Uint8Array(JSON.parse(dataJson) as number[]);\n\n      try {\n        const hash = await crypto.webcrypto.subtle.digest(algorithm, data);\n        return JSON.stringify(Array.from(new Uint8Array(hash)));\n      } catch (err) {\n        if (err instanceof Error) {\n          throw new Error(`[${err.name}]${err.message}`);\n        }\n        throw err;\n      }\n    }\n  );\n  global.setSync(\"__crypto_subtle_digest_ref\", digestRef);\n\n  // crypto.subtle.deriveBits - async reference\n  const deriveBitsRef = new ivm.Reference(\n    async (algorithmJson: string, keyId: number, length: number) => {\n      const algorithm = deserializeAlgorithm(JSON.parse(algorithmJson));\n\n      const cryptoKey = keyMap.get(keyId);\n      if (!cryptoKey) {\n        throw new Error(\"[InvalidAccessError]Key not found\");\n      }\n\n      try {\n        const bits = await crypto.webcrypto.subtle.deriveBits(\n          algorithm as unknown as crypto.webcrypto.EcdhKeyDeriveParams | crypto.webcrypto.HkdfParams | crypto.webcrypto.Pbkdf2Params,\n          cryptoKey,\n          length\n        );\n        return JSON.stringify(Array.from(new Uint8Array(bits)));\n      } catch (err) {\n        if (err instanceof Error) {\n          throw new Error(`[${err.name}]${err.message}`);\n        }\n        throw err;\n      }\n    }\n  );\n  global.setSync(\"__crypto_subtle_deriveBits_ref\", deriveBitsRef);\n\n  // crypto.subtle.deriveKey - async reference\n  const deriveKeyRef = new ivm.Reference(\n    async (\n      algorithmJson: string,\n      baseKeyId: number,\n      derivedKeyAlgorithmJson: string,\n      extractable: boolean,\n      keyUsagesJson: string\n    ) => {\n      const algorithm = deserializeAlgorithm(JSON.parse(algorithmJson));\n      const derivedKeyAlgorithm = JSON.parse(derivedKeyAlgorithmJson);\n      const keyUsages = JSON.parse(keyUsagesJson) as crypto.webcrypto.KeyUsage[];\n\n      const baseKey = keyMap.get(baseKeyId);\n      if (!baseKey) {\n        throw new Error(\"[InvalidAccessError]Key not found\");\n      }\n\n      try {\n        const derivedKey = await crypto.webcrypto.subtle.deriveKey(\n          algorithm as unknown as crypto.webcrypto.EcdhKeyDeriveParams | crypto.webcrypto.HkdfParams | crypto.webcrypto.Pbkdf2Params,\n          baseKey,\n          derivedKeyAlgorithm,\n          extractable,\n          keyUsages\n        );\n\n        // Store derived key on host and return ID\n        const keyId = nextKeyId++;\n        keyMap.set(keyId, derivedKey);\n        return keyId;\n      } catch (err) {\n        if (err instanceof Error) {\n          throw new Error(`[${err.name}]${err.message}`);\n        }\n        throw err;\n      }\n    }\n  );\n  global.setSync(\"__crypto_subtle_deriveKey_ref\", deriveKeyRef);\n\n  // Inject the crypto object into the isolate\n  const cryptoCode = `\n(function() {\n  // DOMException polyfill (Pattern #12)\n  if (typeof DOMException === 'undefined') {\n    globalThis.DOMException = class DOMException extends Error {\n      constructor(message, name) {\n        super(message);\n        this.name = name || 'DOMException';\n      }\n    };\n  }\n\n  // Helper to decode error from host\n  function __decodeError(err) {\n    if (!(err instanceof Error)) return err;\n    const match = err.message.match(/^\\\\[(TypeError|RangeError|NotSupportedError|InvalidAccessError|OperationError|DataError|Error)\\\\](.*)$/);\n    if (match) {\n      if (['NotSupportedError', 'InvalidAccessError', 'OperationError', 'DataError'].includes(match[1])) {\n        return new DOMException(match[2], match[1]);\n      }\n      const ErrorType = globalThis[match[1]] || Error;\n      return new ErrorType(match[2]);\n    }\n    return err;\n  }\n\n  // CryptoKey class to wrap key IDs\n  const _cryptoKeyIds = new WeakMap();\n\n  class CryptoKey {\n    constructor(keyId, algorithm, extractable, usages, type) {\n      _cryptoKeyIds.set(this, keyId);\n      this._algorithm = algorithm;\n      this._extractable = extractable;\n      this._usages = usages;\n      this._type = type || 'secret';\n    }\n\n    _getKeyId() {\n      return _cryptoKeyIds.get(this);\n    }\n\n    get algorithm() {\n      return this._algorithm;\n    }\n\n    get extractable() {\n      return this._extractable;\n    }\n\n    get usages() {\n      return [...this._usages];\n    }\n\n    get type() {\n      return this._type;\n    }\n  }\n\n  globalThis.CryptoKey = CryptoKey;\n\n  // Helper to convert data to byte array\n  function toByteArray(data) {\n    if (typeof data === 'string') {\n      return Array.from(new TextEncoder().encode(data));\n    }\n    if (data instanceof ArrayBuffer) {\n      return Array.from(new Uint8Array(data));\n    }\n    if (ArrayBuffer.isView(data)) {\n      return Array.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));\n    }\n    throw new TypeError('Data must be a BufferSource');\n  }\n\n  // Normalize algorithm to object form\n  function normalizeAlgorithm(algorithm) {\n    if (typeof algorithm === 'string') {\n      return { name: algorithm };\n    }\n    return algorithm;\n  }\n\n  globalThis.crypto = {\n    randomUUID() {\n      return __crypto_randomUUID();\n    },\n\n    getRandomValues(typedArray) {\n      // Validate input is an integer TypedArray\n      if (!(typedArray instanceof Int8Array ||\n            typedArray instanceof Uint8Array ||\n            typedArray instanceof Uint8ClampedArray ||\n            typedArray instanceof Int16Array ||\n            typedArray instanceof Uint16Array ||\n            typedArray instanceof Int32Array ||\n            typedArray instanceof Uint32Array ||\n            typedArray instanceof BigInt64Array ||\n            typedArray instanceof BigUint64Array)) {\n        throw new TypeError(\"Argument 1 must be an integer typed array\");\n      }\n\n      const byteLength = typedArray.byteLength;\n      if (byteLength > 65536) {\n        throw new DOMException(\n          \"The ArrayBufferView's byte length exceeds the number of bytes of entropy available via this API (65536)\",\n          \"QuotaExceededError\"\n        );\n      }\n\n      // Get random bytes from host\n      const bytes = __crypto_getRandomValues(byteLength);\n\n      // Copy bytes into the TypedArray\n      const view = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);\n      for (let i = 0; i < bytes.length; i++) {\n        view[i] = bytes[i];\n      }\n\n      return typedArray;\n    },\n\n    subtle: {\n      async importKey(format, keyData, algorithm, extractable, keyUsages) {\n        try {\n          const normalizedAlgo = normalizeAlgorithm(algorithm);\n          let keyDataJson;\n\n          if (format === 'raw') {\n            keyDataJson = JSON.stringify(toByteArray(keyData));\n          } else if (format === 'jwk') {\n            keyDataJson = JSON.stringify(keyData);\n          } else {\n            throw new DOMException('Unsupported key format: ' + format, 'NotSupportedError');\n          }\n\n          const keyId = await __crypto_subtle_importKey_ref.apply(undefined, [\n            format,\n            keyDataJson,\n            JSON.stringify(normalizedAlgo),\n            extractable,\n            JSON.stringify(keyUsages)\n          ], { result: { promise: true, copy: true } });\n\n          return new CryptoKey(keyId, normalizedAlgo, extractable, keyUsages);\n        } catch (err) {\n          throw __decodeError(err);\n        }\n      },\n\n      async sign(algorithm, key, data) {\n        try {\n          if (!(key instanceof CryptoKey)) {\n            throw new TypeError('Key must be a CryptoKey');\n          }\n          const normalizedAlgo = normalizeAlgorithm(algorithm);\n          const signatureBytesJson = await __crypto_subtle_sign_ref.apply(undefined, [\n            JSON.stringify(normalizedAlgo),\n            key._getKeyId(),\n            JSON.stringify(toByteArray(data))\n          ], { result: { promise: true, copy: true } });\n          const signatureBytes = JSON.parse(signatureBytesJson);\n          return new Uint8Array(signatureBytes).buffer;\n        } catch (err) {\n          throw __decodeError(err);\n        }\n      },\n\n      async verify(algorithm, key, signature, data) {\n        try {\n          if (!(key instanceof CryptoKey)) {\n            throw new TypeError('Key must be a CryptoKey');\n          }\n          const normalizedAlgo = normalizeAlgorithm(algorithm);\n          return await __crypto_subtle_verify_ref.apply(undefined, [\n            JSON.stringify(normalizedAlgo),\n            key._getKeyId(),\n            JSON.stringify(toByteArray(signature)),\n            JSON.stringify(toByteArray(data))\n          ], { result: { promise: true, copy: true } });\n        } catch (err) {\n          throw __decodeError(err);\n        }\n      },\n\n      async digest(algorithm, data) {\n        try {\n          const normalizedAlgo = normalizeAlgorithm(algorithm);\n          const hashBytesJson = await __crypto_subtle_digest_ref.apply(undefined, [\n            JSON.stringify(normalizedAlgo),\n            JSON.stringify(toByteArray(data))\n          ], { result: { promise: true, copy: true } });\n          const hashBytes = JSON.parse(hashBytesJson);\n          return new Uint8Array(hashBytes).buffer;\n        } catch (err) {\n          throw __decodeError(err);\n        }\n      },\n\n      async deriveBits(algorithm, baseKey, length) {\n        try {\n          if (!(baseKey instanceof CryptoKey)) {\n            throw new TypeError('Key must be a CryptoKey');\n          }\n          const normalizedAlgo = normalizeAlgorithm(algorithm);\n          const bitsBytesJson = await __crypto_subtle_deriveBits_ref.apply(undefined, [\n            JSON.stringify(normalizedAlgo),\n            baseKey._getKeyId(),\n            length\n          ], { result: { promise: true, copy: true } });\n          const bitsBytes = JSON.parse(bitsBytesJson);\n          return new Uint8Array(bitsBytes).buffer;\n        } catch (err) {\n          throw __decodeError(err);\n        }\n      },\n\n      async deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {\n        try {\n          if (!(baseKey instanceof CryptoKey)) {\n            throw new TypeError('Key must be a CryptoKey');\n          }\n          const normalizedAlgo = normalizeAlgorithm(algorithm);\n          const normalizedDerivedAlgo = normalizeAlgorithm(derivedKeyAlgorithm);\n          const keyId = await __crypto_subtle_deriveKey_ref.apply(undefined, [\n            JSON.stringify(normalizedAlgo),\n            baseKey._getKeyId(),\n            JSON.stringify(normalizedDerivedAlgo),\n            extractable,\n            JSON.stringify(keyUsages)\n          ], { result: { promise: true, copy: true } });\n          return new CryptoKey(keyId, normalizedDerivedAlgo, extractable, keyUsages);\n        } catch (err) {\n          throw __decodeError(err);\n        }\n      }\n    }\n  };\n})();\n`;\n\n  context.evalSync(cryptoCode);\n\n  return {\n    dispose() {\n      // Clean up key storage for this context\n      keyMap.clear();\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "41260A8CB010326964756E2164756E21",
+  "names": []
+}