@ricsam/quickjs-crypto 0.0.1 → 0.2.13

package/dist/cjs/subtle-crypto.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/subtle-crypto.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { CryptoKeyState, KeyUsage } from \"./types.cjs\";\nimport {\n  nextInstanceId,\n  registerInstance,\n  getInstanceStateById,\n  marshal,\n  unmarshal,\n} from \"@ricsam/quickjs-core\";\n\n/**\n * Helper to create a CryptoKey instance in QuickJS from a host CryptoKey\n *\n * This registers the host key in our state management and creates\n * a QuickJS CryptoKey object that references it via __instanceId__\n */\nexport function createCryptoKeyInstance(\n  context: QuickJSContext,\n  hostKey: globalThis.CryptoKey\n): QuickJSHandle {\n  const instanceId = nextInstanceId();\n\n  const state: CryptoKeyState = {\n    hostKey,\n    type: hostKey.type,\n    extractable: hostKey.extractable,\n    algorithm: hostKey.algorithm as KeyAlgorithm,\n    usages: Array.from(hostKey.usages) as KeyUsage[],\n  };\n\n  registerInstance(instanceId, \"CryptoKey\", state);\n\n  // Create instance via evalCode to properly instantiate with prototype chain\n  const result = context.evalCode(`\n    (function() {\n      const key = Object.create(CryptoKey.prototype);\n      Object.defineProperty(key, '__instanceId__', {\n        value: ${instanceId},\n        enumerable: false,\n        writable: false,\n        configurable: false\n      });\n      return key;\n    })()\n  `);\n\n  if (result.error) {\n    const err = context.dump(result.error);\n    result.error.dispose();\n    throw new Error(`Failed to create CryptoKey instance: ${JSON.stringify(err)}`);\n  }\n\n  return result.value;\n}\n\n/**\n * Helper to create a CryptoKeyPair object in QuickJS\n */\nfunction createCryptoKeyPairInstance(\n  context: QuickJSContext,\n  keyPair: globalThis.CryptoKeyPair\n): QuickJSHandle {\n  const publicKeyHandle = createCryptoKeyInstance(context, keyPair.publicKey);\n  const privateKeyHandle = createCryptoKeyInstance(context, keyPair.privateKey);\n\n  const obj = context.newObject();\n  context.setProp(obj, \"publicKey\", publicKeyHandle);\n  context.setProp(obj, \"privateKey\", privateKeyHandle);\n\n  publicKeyHandle.dispose();\n  privateKeyHandle.dispose();\n\n  return obj;\n}\n\n/**\n * Helper to get the host CryptoKey from a QuickJS CryptoKey handle\n */\nfunction getHostKey(context: QuickJSContext, keyHandle: QuickJSHandle): globalThis.CryptoKey {\n  const instanceIdHandle = context.getProp(keyHandle, \"__instanceId__\");\n  if (context.typeof(instanceIdHandle) !== \"number\") {\n    instanceIdHandle.dispose();\n    throw new Error(\"Invalid CryptoKey: missing __instanceId__\");\n  }\n\n  const instanceId = context.getNumber(instanceIdHandle);\n  instanceIdHandle.dispose();\n\n  const state = getInstanceStateById<CryptoKeyState>(instanceId);\n  if (!state) {\n    throw new Error(\"Invalid CryptoKey: state not found\");\n  }\n\n  return state.hostKey;\n}\n\n/**\n * Helper to safely get an argument from the args array\n */\nfunction getArg(args: QuickJSHandle[], index: number): QuickJSHandle {\n  const arg = args[index];\n  if (!arg) {\n    throw new Error(`Missing argument at index ${index}`);\n  }\n  return arg;\n}\n\n/**\n * Create an async SubtleCrypto method that handles CryptoKey marshalling\n *\n * @param unmarshalArgs - Function to unmarshal arguments synchronously before async work\n * @param implementation - Async implementation that receives unmarshaled args\n */\nfunction createSubtleMethod<T>(\n  context: QuickJSContext,\n  methodName: string,\n  unmarshalArgs: (context: QuickJSContext, args: QuickJSHandle[]) => T,\n  implementation: (context: QuickJSContext, unmarshaledArgs: T) => Promise<QuickJSHandle>\n): QuickJSHandle {\n  return context.newFunction(methodName, (...args) => {\n    const deferred = context.newPromise();\n\n    // Unmarshal arguments synchronously BEFORE scheduling async work\n    // This is critical because the QuickJS handles may be disposed before the microtask runs\n    let unmarshaledArgs: T;\n    try {\n      unmarshaledArgs = unmarshalArgs(context, args);\n    } catch (error) {\n      // If unmarshalling fails, reject immediately\n      const errorHandle = marshal(context, {\n        name: error instanceof Error ? error.name : \"Error\",\n        message: error instanceof Error ? error.message : String(error),\n      });\n      deferred.reject(errorHandle);\n      errorHandle.dispose();\n      context.runtime.executePendingJobs();\n      return deferred.handle;\n    }\n\n    // Run the async implementation in a microtask\n    Promise.resolve().then(async () => {\n      try {\n        const resultHandle = await implementation(context, unmarshaledArgs);\n        deferred.resolve(resultHandle);\n        resultHandle.dispose();\n      } catch (error) {\n        // Use marshal instead of newError to avoid issues with disposed context\n        const errorHandle = marshal(context, {\n          name: error instanceof Error ? error.name : \"Error\",\n          message: error instanceof Error ? error.message : String(error),\n        });\n        deferred.reject(errorHandle);\n        errorHandle.dispose();\n      }\n      context.runtime.executePendingJobs();\n    });\n\n    return deferred.handle;\n  });\n}\n\n// Type definitions for unmarshaled args\ninterface DigestArgs {\n  algorithm: AlgorithmIdentifier;\n  data: Uint8Array;\n}\n\ninterface GenerateKeyArgs {\n  algorithm: RsaHashedKeyGenParams | EcKeyGenParams | AesKeyGenParams | HmacKeyGenParams;\n  extractable: boolean;\n  keyUsages: globalThis.KeyUsage[];\n}\n\ninterface SignArgs {\n  algorithm: AlgorithmIdentifier;\n  key: globalThis.CryptoKey;\n  data: Uint8Array;\n}\n\ninterface VerifyArgs {\n  algorithm: AlgorithmIdentifier;\n  key: globalThis.CryptoKey;\n  signature: Uint8Array;\n  data: Uint8Array;\n}\n\ninterface EncryptDecryptArgs {\n  algorithm: AlgorithmIdentifier;\n  key: globalThis.CryptoKey;\n  data: Uint8Array;\n}\n\ninterface ImportKeyArgs {\n  format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\";\n  keyData: Uint8Array | JsonWebKey;\n  algorithm: AlgorithmIdentifier;\n  extractable: boolean;\n  keyUsages: globalThis.KeyUsage[];\n}\n\ninterface ExportKeyArgs {\n  format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\";\n  key: globalThis.CryptoKey;\n}\n\ninterface DeriveBitsArgs {\n  algorithm: Record<string, unknown>;\n  baseKey: globalThis.CryptoKey;\n  length: number;\n}\n\ninterface DeriveKeyArgs {\n  algorithm: Record<string, unknown>;\n  baseKey: globalThis.CryptoKey;\n  derivedKeyType: AlgorithmIdentifier;\n  extractable: boolean;\n  keyUsages: globalThis.KeyUsage[];\n}\n\ninterface WrapKeyArgs {\n  format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\";\n  key: globalThis.CryptoKey;\n  wrappingKey: globalThis.CryptoKey;\n  wrapAlgorithm: AlgorithmIdentifier;\n}\n\ninterface UnwrapKeyArgs {\n  format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\";\n  wrappedKey: Uint8Array;\n  unwrappingKey: globalThis.CryptoKey;\n  unwrapAlgorithm: AlgorithmIdentifier;\n  unwrappedKeyAlgorithm: AlgorithmIdentifier;\n  extractable: boolean;\n  keyUsages: globalThis.KeyUsage[];\n}\n\n/**\n * Create the SubtleCrypto object with all methods\n */\nexport function createSubtleCryptoObject(context: QuickJSContext): QuickJSHandle {\n  const subtle = context.newObject();\n\n  // digest(algorithm, data) -> ArrayBuffer\n  const digestFn = createSubtleMethod<DigestArgs>(\n    context,\n    \"digest\",\n    (ctx, args) => ({\n      algorithm: unmarshal(ctx, getArg(args, 0)) as AlgorithmIdentifier,\n      data: unmarshal(ctx, getArg(args, 1)) as Uint8Array,\n    }),\n    async (ctx, { algorithm, data }) => {\n      const result = await crypto.subtle.digest(algorithm, data as unknown as BufferSource);\n      return marshal(ctx, new Uint8Array(result));\n    }\n  );\n  context.setProp(subtle, \"digest\", digestFn);\n  digestFn.dispose();\n\n  // generateKey(algorithm, extractable, keyUsages) -> CryptoKey | CryptoKeyPair\n  const generateKeyFn = createSubtleMethod<GenerateKeyArgs>(\n    context,\n    \"generateKey\",\n    (ctx, args) => ({\n      algorithm: unmarshal(ctx, getArg(args, 0)) as GenerateKeyArgs[\"algorithm\"],\n      extractable: unmarshal(ctx, getArg(args, 1)) as boolean,\n      keyUsages: unmarshal(ctx, getArg(args, 2)) as globalThis.KeyUsage[],\n    }),\n    async (ctx, { algorithm, extractable, keyUsages }) => {\n      const result = await crypto.subtle.generateKey(algorithm, extractable, keyUsages);\n\n      // Check if it's a key pair or single key\n      if (\"publicKey\" in result && \"privateKey\" in result) {\n        return createCryptoKeyPairInstance(ctx, result);\n      } else {\n        return createCryptoKeyInstance(ctx, result as globalThis.CryptoKey);\n      }\n    }\n  );\n  context.setProp(subtle, \"generateKey\", generateKeyFn);\n  generateKeyFn.dispose();\n\n  // sign(algorithm, key, data) -> ArrayBuffer\n  const signFn = createSubtleMethod<SignArgs>(\n    context,\n    \"sign\",\n    (ctx, args) => ({\n      algorithm: unmarshal(ctx, getArg(args, 0)) as AlgorithmIdentifier,\n      key: getHostKey(ctx, getArg(args, 1)),\n      data: unmarshal(ctx, getArg(args, 2)) as Uint8Array,\n    }),\n    async (ctx, { algorithm, key, data }) => {\n      const result = await crypto.subtle.sign(algorithm, key, data as unknown as BufferSource);\n      return marshal(ctx, new Uint8Array(result));\n    }\n  );\n  context.setProp(subtle, \"sign\", signFn);\n  signFn.dispose();\n\n  // verify(algorithm, key, signature, data) -> boolean\n  const verifyFn = createSubtleMethod<VerifyArgs>(\n    context,\n    \"verify\",\n    (ctx, args) => ({\n      algorithm: unmarshal(ctx, getArg(args, 0)) as AlgorithmIdentifier,\n      key: getHostKey(ctx, getArg(args, 1)),\n      signature: unmarshal(ctx, getArg(args, 2)) as Uint8Array,\n      data: unmarshal(ctx, getArg(args, 3)) as Uint8Array,\n    }),\n    async (ctx, { algorithm, key, signature, data }) => {\n      const result = await crypto.subtle.verify(\n        algorithm,\n        key,\n        signature as unknown as BufferSource,\n        data as unknown as BufferSource\n      );\n      return marshal(ctx, result);\n    }\n  );\n  context.setProp(subtle, \"verify\", verifyFn);\n  verifyFn.dispose();\n\n  // encrypt(algorithm, key, data) -> ArrayBuffer\n  const encryptFn = createSubtleMethod<EncryptDecryptArgs>(\n    context,\n    \"encrypt\",\n    (ctx, args) => ({\n      algorithm: unmarshal(ctx, getArg(args, 0)) as AlgorithmIdentifier,\n      key: getHostKey(ctx, getArg(args, 1)),\n      data: unmarshal(ctx, getArg(args, 2)) as Uint8Array,\n    }),\n    async (ctx, { algorithm, key, data }) => {\n      const result = await crypto.subtle.encrypt(\n        algorithm,\n        key,\n        data as unknown as BufferSource\n      );\n      return marshal(ctx, new Uint8Array(result));\n    }\n  );\n  context.setProp(subtle, \"encrypt\", encryptFn);\n  encryptFn.dispose();\n\n  // decrypt(algorithm, key, data) -> ArrayBuffer\n  const decryptFn = createSubtleMethod<EncryptDecryptArgs>(\n    context,\n    \"decrypt\",\n    (ctx, args) => ({\n      algorithm: unmarshal(ctx, getArg(args, 0)) as AlgorithmIdentifier,\n      key: getHostKey(ctx, getArg(args, 1)),\n      data: unmarshal(ctx, getArg(args, 2)) as Uint8Array,\n    }),\n    async (ctx, { algorithm, key, data }) => {\n      const result = await crypto.subtle.decrypt(\n        algorithm,\n        key,\n        data as unknown as BufferSource\n      );\n      return marshal(ctx, new Uint8Array(result));\n    }\n  );\n  context.setProp(subtle, \"decrypt\", decryptFn);\n  decryptFn.dispose();\n\n  // importKey(format, keyData, algorithm, extractable, keyUsages) -> CryptoKey\n  const importKeyFn = createSubtleMethod<ImportKeyArgs>(\n    context,\n    \"importKey\",\n    (ctx, args) => ({\n      format: unmarshal(ctx, getArg(args, 0)) as ImportKeyArgs[\"format\"],\n      keyData: unmarshal(ctx, getArg(args, 1)) as Uint8Array | JsonWebKey,\n      algorithm: unmarshal(ctx, getArg(args, 2)) as AlgorithmIdentifier,\n      extractable: unmarshal(ctx, getArg(args, 3)) as boolean,\n      keyUsages: unmarshal(ctx, getArg(args, 4)) as globalThis.KeyUsage[],\n    }),\n    async (ctx, { format, keyData, algorithm, extractable, keyUsages }) => {\n      let result: globalThis.CryptoKey;\n\n      if (format === \"jwk\") {\n        // JWK format expects JsonWebKey\n        result = await crypto.subtle.importKey(\n          format,\n          keyData as JsonWebKey,\n          algorithm,\n          extractable,\n          keyUsages\n        );\n      } else {\n        // Non-jwk formats expect BufferSource\n        // Convert Uint8Array to ArrayBuffer\n        let data: BufferSource;\n        if (keyData instanceof Uint8Array) {\n          data = keyData.buffer.slice(keyData.byteOffset, keyData.byteOffset + keyData.byteLength) as ArrayBuffer;\n        } else {\n          data = keyData as BufferSource;\n        }\n\n        result = await crypto.subtle.importKey(\n          format,\n          data,\n          algorithm,\n          extractable,\n          keyUsages\n        ) as globalThis.CryptoKey;\n      }\n\n      return createCryptoKeyInstance(ctx, result);\n    }\n  );\n  context.setProp(subtle, \"importKey\", importKeyFn);\n  importKeyFn.dispose();\n\n  // exportKey(format, key) -> ArrayBuffer | JsonWebKey\n  const exportKeyFn = createSubtleMethod<ExportKeyArgs>(\n    context,\n    \"exportKey\",\n    (ctx, args) => ({\n      format: unmarshal(ctx, getArg(args, 0)) as ExportKeyArgs[\"format\"],\n      key: getHostKey(ctx, getArg(args, 1)),\n    }),\n    async (ctx, { format, key }) => {\n      const result = await crypto.subtle.exportKey(format, key);\n\n      if (result instanceof ArrayBuffer) {\n        return marshal(ctx, new Uint8Array(result));\n      } else {\n        // JsonWebKey - marshal as plain object\n        return marshal(ctx, result);\n      }\n    }\n  );\n  context.setProp(subtle, \"exportKey\", exportKeyFn);\n  exportKeyFn.dispose();\n\n  // deriveBits(algorithm, baseKey, length) -> ArrayBuffer\n  const deriveBitsFn = createSubtleMethod<DeriveBitsArgs>(\n    context,\n    \"deriveBits\",\n    (ctx, args) => {\n      const algorithmRaw = unmarshal(ctx, getArg(args, 0)) as Record<string, unknown>;\n      const baseKey = getHostKey(ctx, getArg(args, 1));\n      const length = unmarshal(ctx, getArg(args, 2)) as number;\n\n      // If the algorithm has a 'public' property, it needs to be a CryptoKey\n      let algorithm = algorithmRaw;\n      if (algorithmRaw.public && typeof algorithmRaw.public === \"object\") {\n        const publicKeyData = algorithmRaw.public as { __instanceId__?: number };\n        if (publicKeyData.__instanceId__ !== undefined) {\n          const publicKeyState = getInstanceStateById<CryptoKeyState>(publicKeyData.__instanceId__);\n          if (publicKeyState) {\n            algorithm = { ...algorithmRaw, public: publicKeyState.hostKey };\n          }\n        }\n      }\n\n      return { algorithm, baseKey, length };\n    },\n    async (ctx, { algorithm, baseKey, length }) => {\n      const result = await crypto.subtle.deriveBits(\n        algorithm as unknown as AlgorithmIdentifier,\n        baseKey,\n        length\n      );\n      return marshal(ctx, new Uint8Array(result));\n    }\n  );\n  context.setProp(subtle, \"deriveBits\", deriveBitsFn);\n  deriveBitsFn.dispose();\n\n  // deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages) -> CryptoKey\n  const deriveKeyFn = createSubtleMethod<DeriveKeyArgs>(\n    context,\n    \"deriveKey\",\n    (ctx, args) => {\n      const algorithmRaw = unmarshal(ctx, getArg(args, 0)) as Record<string, unknown>;\n      const baseKey = getHostKey(ctx, getArg(args, 1));\n      const derivedKeyType = unmarshal(ctx, getArg(args, 2)) as AlgorithmIdentifier;\n      const extractable = unmarshal(ctx, getArg(args, 3)) as boolean;\n      const keyUsages = unmarshal(ctx, getArg(args, 4)) as globalThis.KeyUsage[];\n\n      // If the algorithm has a 'public' property, it needs to be a CryptoKey\n      let algorithm = algorithmRaw;\n      if (algorithmRaw.public && typeof algorithmRaw.public === \"object\") {\n        const publicKeyData = algorithmRaw.public as { __instanceId__?: number };\n        if (publicKeyData.__instanceId__ !== undefined) {\n          const publicKeyState = getInstanceStateById<CryptoKeyState>(publicKeyData.__instanceId__);\n          if (publicKeyState) {\n            algorithm = { ...algorithmRaw, public: publicKeyState.hostKey };\n          }\n        }\n      }\n\n      return { algorithm, baseKey, derivedKeyType, extractable, keyUsages };\n    },\n    async (ctx, { algorithm, baseKey, derivedKeyType, extractable, keyUsages }) => {\n      const result = await crypto.subtle.deriveKey(\n        algorithm as unknown as AlgorithmIdentifier,\n        baseKey,\n        derivedKeyType,\n        extractable,\n        keyUsages\n      );\n\n      return createCryptoKeyInstance(ctx, result as globalThis.CryptoKey);\n    }\n  );\n  context.setProp(subtle, \"deriveKey\", deriveKeyFn);\n  deriveKeyFn.dispose();\n\n  // wrapKey(format, key, wrappingKey, wrapAlgorithm) -> ArrayBuffer\n  const wrapKeyFn = createSubtleMethod<WrapKeyArgs>(\n    context,\n    \"wrapKey\",\n    (ctx, args) => ({\n      format: unmarshal(ctx, getArg(args, 0)) as WrapKeyArgs[\"format\"],\n      key: getHostKey(ctx, getArg(args, 1)),\n      wrappingKey: getHostKey(ctx, getArg(args, 2)),\n      wrapAlgorithm: unmarshal(ctx, getArg(args, 3)) as AlgorithmIdentifier,\n    }),\n    async (ctx, { format, key, wrappingKey, wrapAlgorithm }) => {\n      const result = await crypto.subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm);\n      return marshal(ctx, new Uint8Array(result));\n    }\n  );\n  context.setProp(subtle, \"wrapKey\", wrapKeyFn);\n  wrapKeyFn.dispose();\n\n  // unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) -> CryptoKey\n  const unwrapKeyFn = createSubtleMethod<UnwrapKeyArgs>(\n    context,\n    \"unwrapKey\",\n    (ctx, args) => ({\n      format: unmarshal(ctx, getArg(args, 0)) as UnwrapKeyArgs[\"format\"],\n      wrappedKey: unmarshal(ctx, getArg(args, 1)) as Uint8Array,\n      unwrappingKey: getHostKey(ctx, getArg(args, 2)),\n      unwrapAlgorithm: unmarshal(ctx, getArg(args, 3)) as AlgorithmIdentifier,\n      unwrappedKeyAlgorithm: unmarshal(ctx, getArg(args, 4)) as AlgorithmIdentifier,\n      extractable: unmarshal(ctx, getArg(args, 5)) as boolean,\n      keyUsages: unmarshal(ctx, getArg(args, 6)) as globalThis.KeyUsage[],\n    }),\n    async (ctx, { format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages }) => {\n      const result = await crypto.subtle.unwrapKey(\n        format,\n        wrappedKey as unknown as BufferSource,\n        unwrappingKey,\n        unwrapAlgorithm,\n        unwrappedKeyAlgorithm,\n        extractable,\n        keyUsages\n      );\n\n      return createCryptoKeyInstance(ctx, result as globalThis.CryptoKey);\n    }\n  );\n  context.setProp(subtle, \"unwrapKey\", unwrapKeyFn);\n  unwrapKeyFn.dispose();\n\n  return subtle;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "C0DB512361613CD264756E2164756E21",
+  "names": []
+}

package/dist/cjs/types.cjs

@@ -0,0 +1,26 @@
+// @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;
+};
+
+// packages/crypto/src/types.ts
+var exports_types = {};
+module.exports = __toCommonJS(exports_types);
+})
+
+//# debugId=E81E3EE1B2E61F0D64756E2164756E21

package/dist/cjs/types.cjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "E81E3EE1B2E61F0D64756E2164756E21",
+  "names": []
+}

package/dist/mjs/crypto-key.mjs

@@ -0,0 +1,39 @@
+// @bun
+// packages/crypto/src/crypto-key.ts
+import { defineClass } from "@ricsam/quickjs-core";
+function createCryptoKeyClass(context, stateMap) {
+  return defineClass(context, stateMap, {
+    name: "CryptoKey",
+    construct: () => {
+      throw new Error("CryptoKey cannot be constructed directly. Use crypto.subtle methods instead.");
+    },
+    properties: {
+      type: {
+        get() {
+          return this.type;
+        }
+      },
+      extractable: {
+        get() {
+          return this.extractable;
+        }
+      },
+      algorithm: {
+        get() {
+          return { ...this.algorithm };
+        }
+      },
+      usages: {
+        get() {
+          return [...this.usages];
+        }
+      }
+    },
+    methods: {}
+  });
+}
+export {
+  createCryptoKeyClass
+};
+
+//# debugId=1FDEB7435B7912AF64756E2164756E21

package/dist/mjs/crypto-key.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/crypto-key.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { StateMap, CryptoKeyState } from \"./types.mjs\";\nimport { defineClass } from \"@ricsam/quickjs-core\";\n\n/**\n * Create the CryptoKey class for the QuickJS context\n *\n * CryptoKey is an opaque type - the actual key material stays on the host.\n * The QuickJS instance only holds metadata and an instanceId that maps\n * to the host-side CryptoKey.\n */\nexport function createCryptoKeyClass(\n  context: QuickJSContext,\n  stateMap: StateMap\n): QuickJSHandle {\n  return defineClass<CryptoKeyState>(context, stateMap, {\n    name: \"CryptoKey\",\n    // CryptoKey cannot be constructed directly - only via SubtleCrypto methods\n    construct: () => {\n      throw new Error(\n        \"CryptoKey cannot be constructed directly. Use crypto.subtle methods instead.\"\n      );\n    },\n    properties: {\n      type: {\n        get(this: CryptoKeyState) {\n          return this.type;\n        },\n      },\n      extractable: {\n        get(this: CryptoKeyState) {\n          return this.extractable;\n        },\n      },\n      algorithm: {\n        get(this: CryptoKeyState) {\n          // Return a copy of the algorithm object to prevent mutation\n          return { ...this.algorithm };\n        },\n      },\n      usages: {\n        get(this: CryptoKeyState) {\n          // Return a copy of usages array to prevent mutation\n          return [...this.usages];\n        },\n      },\n    },\n    methods: {},\n  });\n}\n"
+  ],
+  "mappings": ";;AAEA;AASO,SAAS,oBAAoB,CAClC,SACA,UACe;AAAA,EACf,OAAO,YAA4B,SAAS,UAAU;AAAA,IACpD,MAAM;AAAA,IAEN,WAAW,MAAM;AAAA,MACf,MAAM,IAAI,MACR,8EACF;AAAA;AAAA,IAEF,YAAY;AAAA,MACV,MAAM;AAAA,QACJ,GAAG,GAAuB;AAAA,UACxB,OAAO,KAAK;AAAA;AAAA,MAEhB;AAAA,MACA,aAAa;AAAA,QACX,GAAG,GAAuB;AAAA,UACxB,OAAO,KAAK;AAAA;AAAA,MAEhB;AAAA,MACA,WAAW;AAAA,QACT,GAAG,GAAuB;AAAA,UAExB,OAAO,KAAK,KAAK,UAAU;AAAA;AAAA,MAE/B;AAAA,MACA,QAAQ;AAAA,QACN,GAAG,GAAuB;AAAA,UAExB,OAAO,CAAC,GAAG,KAAK,MAAM;AAAA;AAAA,MAE1B;AAAA,IACF;AAAA,IACA,SAAS,CAAC;AAAA,EACZ,CAAC;AAAA;",
+  "debugId": "1FDEB7435B7912AF64756E2164756E21",
+  "names": []
+}

package/dist/mjs/index.mjs

@@ -0,0 +1,10 @@
+// @bun
+// packages/crypto/src/index.ts
+import { setupCrypto } from "./setup.mjs";
+import { createCryptoKeyInstance } from "./subtle-crypto.mjs";
+export {
+  setupCrypto,
+  createCryptoKeyInstance
+};
+
+//# debugId=B1814670BBC9E6F064756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "export { setupCrypto } from \"./setup.mjs\";\nexport type {\n  SetupCryptoOptions,\n  CryptoHandle,\n  CryptoKeyState,\n  KeyUsage,\n  KeyType,\n} from \"./types.mjs\";\nexport { createCryptoKeyInstance } from \"./subtle-crypto.mjs\";\n"
+  ],
+  "mappings": ";;AAAA;AAQA;",
+  "debugId": "B1814670BBC9E6F064756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/quickjs-crypto",
+  "version": "0.2.13",
+  "type": "module"
+}

package/dist/mjs/random.mjs

@@ -0,0 +1,58 @@
+// @bun
+// packages/crypto/src/random.ts
+import { marshal } from "@ricsam/quickjs-core";
+function createGetRandomValuesFunction(context) {
+  return context.newFunction("getRandomValues", (arrayHandle) => {
+    const byteLengthHandle = context.getProp(arrayHandle, "byteLength");
+    const byteLengthType = context.typeof(byteLengthHandle);
+    if (byteLengthType !== "number") {
+      byteLengthHandle.dispose();
+      throw context.newError("getRandomValues: argument must be an integer-typed TypedArray");
+    }
+    const byteLength = context.getNumber(byteLengthHandle);
+    byteLengthHandle.dispose();
+    if (byteLength > 65536) {
+      throw context.newError("getRandomValues: quota exceeded (max 65536 bytes)");
+    }
+    const randomBytes = new Uint8Array(byteLength);
+    crypto.getRandomValues(randomBytes);
+    const bytesArray = Array.from(randomBytes);
+    const setValuesResult = context.evalCode(`
+      (function(typedArray, bytes) {
+        const view = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+        for (let i = 0; i < bytes.length; i++) {
+          view[i] = bytes[i];
+        }
+        return typedArray;
+      })
+    `);
+    if (setValuesResult.error) {
+      const err = context.dump(setValuesResult.error);
+      setValuesResult.error.dispose();
+      throw context.newError(`getRandomValues failed: ${JSON.stringify(err)}`);
+    }
+    const setValuesFn = setValuesResult.value;
+    const bytesHandle = marshal(context, bytesArray);
+    const result = context.callFunction(setValuesFn, context.undefined, arrayHandle, bytesHandle);
+    setValuesFn.dispose();
+    bytesHandle.dispose();
+    if (result.error) {
+      const err = context.dump(result.error);
+      result.error.dispose();
+      throw context.newError(`getRandomValues failed: ${JSON.stringify(err)}`);
+    }
+    return result.value;
+  });
+}
+function createRandomUUIDFunction(context) {
+  return context.newFunction("randomUUID", () => {
+    const uuid = crypto.randomUUID();
+    return context.newString(uuid);
+  });
+}
+export {
+  createRandomUUIDFunction,
+  createGetRandomValuesFunction
+};
+
+//# debugId=972D3D366A2BF23664756E2164756E21

package/dist/mjs/random.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/random.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport { marshal } from \"@ricsam/quickjs-core\";\n\n/**\n * Create the getRandomValues function for the crypto global\n *\n * getRandomValues fills a TypedArray with cryptographically random values\n * and returns the same array (modified in-place)\n */\nexport function createGetRandomValuesFunction(\n  context: QuickJSContext\n): QuickJSHandle {\n  return context.newFunction(\"getRandomValues\", (arrayHandle) => {\n    // Get byteLength to determine how many random bytes we need\n    const byteLengthHandle = context.getProp(arrayHandle, \"byteLength\");\n    const byteLengthType = context.typeof(byteLengthHandle);\n\n    if (byteLengthType !== \"number\") {\n      byteLengthHandle.dispose();\n      throw context.newError(\n        \"getRandomValues: argument must be an integer-typed TypedArray\"\n      );\n    }\n\n    const byteLength = context.getNumber(byteLengthHandle);\n    byteLengthHandle.dispose();\n\n    if (byteLength > 65536) {\n      throw context.newError(\n        \"getRandomValues: quota exceeded (max 65536 bytes)\"\n      );\n    }\n\n    // Generate random bytes on the host\n    const randomBytes = new Uint8Array(byteLength);\n    crypto.getRandomValues(randomBytes);\n\n    // Convert to array of numbers for JSON serialization\n    const bytesArray = Array.from(randomBytes);\n\n    // Use evalCode to copy the bytes into the TypedArray\n    // We pass the array handle and use a helper to set the values\n    const setValuesResult = context.evalCode(`\n      (function(typedArray, bytes) {\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        return typedArray;\n      })\n    `);\n\n    if (setValuesResult.error) {\n      const err = context.dump(setValuesResult.error);\n      setValuesResult.error.dispose();\n      throw context.newError(`getRandomValues failed: ${JSON.stringify(err)}`);\n    }\n\n    const setValuesFn = setValuesResult.value;\n    const bytesHandle = marshal(context, bytesArray);\n\n    const result = context.callFunction(\n      setValuesFn,\n      context.undefined,\n      arrayHandle,\n      bytesHandle\n    );\n\n    setValuesFn.dispose();\n    bytesHandle.dispose();\n\n    if (result.error) {\n      const err = context.dump(result.error);\n      result.error.dispose();\n      throw context.newError(`getRandomValues failed: ${JSON.stringify(err)}`);\n    }\n\n    return result.value;\n  });\n}\n\n/**\n * Create the randomUUID function for the crypto global\n *\n * randomUUID returns a string containing a randomly generated UUID v4\n */\nexport function createRandomUUIDFunction(\n  context: QuickJSContext\n): QuickJSHandle {\n  return context.newFunction(\"randomUUID\", () => {\n    const uuid = crypto.randomUUID();\n    return context.newString(uuid);\n  });\n}\n"
+  ],
+  "mappings": ";;AACA;AAQO,SAAS,6BAA6B,CAC3C,SACe;AAAA,EACf,OAAO,QAAQ,YAAY,mBAAmB,CAAC,gBAAgB;AAAA,IAE7D,MAAM,mBAAmB,QAAQ,QAAQ,aAAa,YAAY;AAAA,IAClE,MAAM,iBAAiB,QAAQ,OAAO,gBAAgB;AAAA,IAEtD,IAAI,mBAAmB,UAAU;AAAA,MAC/B,iBAAiB,QAAQ;AAAA,MACzB,MAAM,QAAQ,SACZ,+DACF;AAAA,IACF;AAAA,IAEA,MAAM,aAAa,QAAQ,UAAU,gBAAgB;AAAA,IACrD,iBAAiB,QAAQ;AAAA,IAEzB,IAAI,aAAa,OAAO;AAAA,MACtB,MAAM,QAAQ,SACZ,mDACF;AAAA,IACF;AAAA,IAGA,MAAM,cAAc,IAAI,WAAW,UAAU;AAAA,IAC7C,OAAO,gBAAgB,WAAW;AAAA,IAGlC,MAAM,aAAa,MAAM,KAAK,WAAW;AAAA,IAIzC,MAAM,kBAAkB,QAAQ,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAQxC;AAAA,IAED,IAAI,gBAAgB,OAAO;AAAA,MACzB,MAAM,MAAM,QAAQ,KAAK,gBAAgB,KAAK;AAAA,MAC9C,gBAAgB,MAAM,QAAQ;AAAA,MAC9B,MAAM,QAAQ,SAAS,2BAA2B,KAAK,UAAU,GAAG,GAAG;AAAA,IACzE;AAAA,IAEA,MAAM,cAAc,gBAAgB;AAAA,IACpC,MAAM,cAAc,QAAQ,SAAS,UAAU;AAAA,IAE/C,MAAM,SAAS,QAAQ,aACrB,aACA,QAAQ,WACR,aACA,WACF;AAAA,IAEA,YAAY,QAAQ;AAAA,IACpB,YAAY,QAAQ;AAAA,IAEpB,IAAI,OAAO,OAAO;AAAA,MAChB,MAAM,MAAM,QAAQ,KAAK,OAAO,KAAK;AAAA,MACrC,OAAO,MAAM,QAAQ;AAAA,MACrB,MAAM,QAAQ,SAAS,2BAA2B,KAAK,UAAU,GAAG,GAAG;AAAA,IACzE;AAAA,IAEA,OAAO,OAAO;AAAA,GACf;AAAA;AAQI,SAAS,wBAAwB,CACtC,SACe;AAAA,EACf,OAAO,QAAQ,YAAY,cAAc,MAAM;AAAA,IAC7C,MAAM,OAAO,OAAO,WAAW;AAAA,IAC/B,OAAO,QAAQ,UAAU,IAAI;AAAA,GAC9B;AAAA;",
+  "debugId": "972D3D366A2BF23664756E2164756E21",
+  "names": []
+}

package/dist/mjs/setup.mjs

@@ -0,0 +1,60 @@
+// @bun
+// packages/crypto/src/setup.ts
+import { setupCore } from "@ricsam/quickjs-core";
+import { createCryptoKeyClass } from "./crypto-key.mjs";
+import { createSubtleCryptoObject } from "./subtle-crypto.mjs";
+import {
+  createGetRandomValuesFunction,
+  createRandomUUIDFunction
+} from "./random.mjs";
+function setupCrypto(context, options = {}) {
+  const coreHandle = options.coreHandle ?? setupCore(context, { stateMap: options.stateMap });
+  const stateMap = options.stateMap ?? coreHandle.stateMap;
+  const CryptoKeyClass = createCryptoKeyClass(context, stateMap);
+  context.setProp(context.global, "CryptoKey", CryptoKeyClass);
+  CryptoKeyClass.dispose();
+  const subtleCrypto = createSubtleCryptoObject(context);
+  const cryptoObj = context.newObject();
+  const subtlePropResult = context.evalCode(`
+    (function(crypto, subtle) {
+      Object.defineProperty(crypto, 'subtle', {
+        value: subtle,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      });
+    })
+  `);
+  if (subtlePropResult.error) {
+    const err = context.dump(subtlePropResult.error);
+    subtlePropResult.error.dispose();
+    throw new Error(`Failed to setup crypto.subtle: ${JSON.stringify(err)}`);
+  }
+  const defineSubtleFn = subtlePropResult.value;
+  const defineResult = context.callFunction(defineSubtleFn, context.undefined, cryptoObj, subtleCrypto);
+  defineSubtleFn.dispose();
+  subtleCrypto.dispose();
+  if (defineResult.error) {
+    const err = context.dump(defineResult.error);
+    defineResult.error.dispose();
+    throw new Error(`Failed to setup crypto.subtle: ${JSON.stringify(err)}`);
+  }
+  defineResult.value.dispose();
+  const getRandomValuesFn = createGetRandomValuesFunction(context);
+  context.setProp(cryptoObj, "getRandomValues", getRandomValuesFn);
+  getRandomValuesFn.dispose();
+  const randomUUIDFn = createRandomUUIDFunction(context);
+  context.setProp(cryptoObj, "randomUUID", randomUUIDFn);
+  randomUUIDFn.dispose();
+  context.setProp(context.global, "crypto", cryptoObj);
+  cryptoObj.dispose();
+  return {
+    stateMap,
+    dispose() {}
+  };
+}
+export {
+  setupCrypto
+};
+
+//# debugId=B776A934B2F9E4B364756E2164756E21

package/dist/mjs/setup.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/setup.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext } from \"quickjs-emscripten\";\nimport { setupCore, createStateMap } from \"@ricsam/quickjs-core\";\nimport type { SetupCryptoOptions, CryptoHandle } from \"./types.mjs\";\nimport { createCryptoKeyClass } from \"./crypto-key.mjs\";\nimport { createSubtleCryptoObject } from \"./subtle-crypto.mjs\";\nimport {\n  createGetRandomValuesFunction,\n  createRandomUUIDFunction,\n} from \"./random.mjs\";\n\n/**\n * Setup crypto globals in a QuickJS context\n *\n * Provides: crypto.subtle (SubtleCrypto), crypto.getRandomValues, crypto.randomUUID, CryptoKey\n *\n * @example\n * ```typescript\n * const handle = setupCrypto(context);\n *\n * context.evalCode(`\n *   // Generate a random UUID\n *   const uuid = crypto.randomUUID();\n *\n *   // Generate random bytes\n *   const arr = new Uint8Array(16);\n *   crypto.getRandomValues(arr);\n *\n *   // Use SubtleCrypto for encryption\n *   const key = await crypto.subtle.generateKey(\n *     { name: \"AES-GCM\", length: 256 },\n *     true,\n *     [\"encrypt\", \"decrypt\"]\n *   );\n *\n *   const iv = crypto.getRandomValues(new Uint8Array(12));\n *   const data = new TextEncoder().encode(\"secret message\");\n *   const encrypted = await crypto.subtle.encrypt(\n *     { name: \"AES-GCM\", iv },\n *     key,\n *     data\n *   );\n * `);\n *\n * handle.dispose();\n * ```\n *\n * @param context - QuickJS context\n * @param options - Setup options\n * @returns CryptoHandle for cleanup\n */\nexport function setupCrypto(\n  context: QuickJSContext,\n  options: SetupCryptoOptions = {}\n): CryptoHandle {\n  // Setup core if not provided (needed for marshal/unmarshal infrastructure)\n  const coreHandle =\n    options.coreHandle ?? setupCore(context, { stateMap: options.stateMap });\n  const stateMap = options.stateMap ?? coreHandle.stateMap;\n\n  // 1. Create and register CryptoKey class (needed by SubtleCrypto)\n  const CryptoKeyClass = createCryptoKeyClass(context, stateMap);\n  context.setProp(context.global, \"CryptoKey\", CryptoKeyClass);\n  CryptoKeyClass.dispose();\n\n  // 2. Create the SubtleCrypto object\n  const subtleCrypto = createSubtleCryptoObject(context);\n\n  // 3. Create the crypto global object\n  const cryptoObj = context.newObject();\n\n  // Set subtle as a non-writable property\n  const subtlePropResult = context.evalCode(`\n    (function(crypto, subtle) {\n      Object.defineProperty(crypto, 'subtle', {\n        value: subtle,\n        writable: false,\n        enumerable: true,\n        configurable: false\n      });\n    })\n  `);\n\n  if (subtlePropResult.error) {\n    const err = context.dump(subtlePropResult.error);\n    subtlePropResult.error.dispose();\n    throw new Error(`Failed to setup crypto.subtle: ${JSON.stringify(err)}`);\n  }\n\n  const defineSubtleFn = subtlePropResult.value;\n  const defineResult = context.callFunction(\n    defineSubtleFn,\n    context.undefined,\n    cryptoObj,\n    subtleCrypto\n  );\n  defineSubtleFn.dispose();\n  subtleCrypto.dispose();\n\n  if (defineResult.error) {\n    const err = context.dump(defineResult.error);\n    defineResult.error.dispose();\n    throw new Error(`Failed to setup crypto.subtle: ${JSON.stringify(err)}`);\n  }\n  defineResult.value.dispose();\n\n  // 4. Set getRandomValues on crypto object\n  const getRandomValuesFn = createGetRandomValuesFunction(context);\n  context.setProp(cryptoObj, \"getRandomValues\", getRandomValuesFn);\n  getRandomValuesFn.dispose();\n\n  // 5. Set randomUUID on crypto object\n  const randomUUIDFn = createRandomUUIDFunction(context);\n  context.setProp(cryptoObj, \"randomUUID\", randomUUIDFn);\n  randomUUIDFn.dispose();\n\n  // 6. Set crypto on global\n  context.setProp(context.global, \"crypto\", cryptoObj);\n  cryptoObj.dispose();\n\n  return {\n    stateMap,\n    dispose() {\n      // Globals are owned by context.global, cleaned up by context.dispose()\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;AACA;AAEA;AACA;AACA;AAAA;AAAA;AAAA;AA6CO,SAAS,WAAW,CACzB,SACA,UAA8B,CAAC,GACjB;AAAA,EAEd,MAAM,aACJ,QAAQ,cAAc,UAAU,SAAS,EAAE,UAAU,QAAQ,SAAS,CAAC;AAAA,EACzE,MAAM,WAAW,QAAQ,YAAY,WAAW;AAAA,EAGhD,MAAM,iBAAiB,qBAAqB,SAAS,QAAQ;AAAA,EAC7D,QAAQ,QAAQ,QAAQ,QAAQ,aAAa,cAAc;AAAA,EAC3D,eAAe,QAAQ;AAAA,EAGvB,MAAM,eAAe,yBAAyB,OAAO;AAAA,EAGrD,MAAM,YAAY,QAAQ,UAAU;AAAA,EAGpC,MAAM,mBAAmB,QAAQ,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GASzC;AAAA,EAED,IAAI,iBAAiB,OAAO;AAAA,IAC1B,MAAM,MAAM,QAAQ,KAAK,iBAAiB,KAAK;AAAA,IAC/C,iBAAiB,MAAM,QAAQ;AAAA,IAC/B,MAAM,IAAI,MAAM,kCAAkC,KAAK,UAAU,GAAG,GAAG;AAAA,EACzE;AAAA,EAEA,MAAM,iBAAiB,iBAAiB;AAAA,EACxC,MAAM,eAAe,QAAQ,aAC3B,gBACA,QAAQ,WACR,WACA,YACF;AAAA,EACA,eAAe,QAAQ;AAAA,EACvB,aAAa,QAAQ;AAAA,EAErB,IAAI,aAAa,OAAO;AAAA,IACtB,MAAM,MAAM,QAAQ,KAAK,aAAa,KAAK;AAAA,IAC3C,aAAa,MAAM,QAAQ;AAAA,IAC3B,MAAM,IAAI,MAAM,kCAAkC,KAAK,UAAU,GAAG,GAAG;AAAA,EACzE;AAAA,EACA,aAAa,MAAM,QAAQ;AAAA,EAG3B,MAAM,oBAAoB,8BAA8B,OAAO;AAAA,EAC/D,QAAQ,QAAQ,WAAW,mBAAmB,iBAAiB;AAAA,EAC/D,kBAAkB,QAAQ;AAAA,EAG1B,MAAM,eAAe,yBAAyB,OAAO;AAAA,EACrD,QAAQ,QAAQ,WAAW,cAAc,YAAY;AAAA,EACrD,aAAa,QAAQ;AAAA,EAGrB,QAAQ,QAAQ,QAAQ,QAAQ,UAAU,SAAS;AAAA,EACnD,UAAU,QAAQ;AAAA,EAElB,OAAO;AAAA,IACL;AAAA,IACA,OAAO,GAAG;AAAA,EAGZ;AAAA;",
+  "debugId": "B776A934B2F9E4B364756E2164756E21",
+  "names": []
+}

package/dist/mjs/subtle-crypto.mjs

@@ -0,0 +1,282 @@
+// @bun
+// packages/crypto/src/subtle-crypto.ts
+import {
+  nextInstanceId,
+  registerInstance,
+  getInstanceStateById,
+  marshal,
+  unmarshal
+} from "@ricsam/quickjs-core";
+function createCryptoKeyInstance(context, hostKey) {
+  const instanceId = nextInstanceId();
+  const state = {
+    hostKey,
+    type: hostKey.type,
+    extractable: hostKey.extractable,
+    algorithm: hostKey.algorithm,
+    usages: Array.from(hostKey.usages)
+  };
+  registerInstance(instanceId, "CryptoKey", state);
+  const result = context.evalCode(`
+    (function() {
+      const key = Object.create(CryptoKey.prototype);
+      Object.defineProperty(key, '__instanceId__', {
+        value: ${instanceId},
+        enumerable: false,
+        writable: false,
+        configurable: false
+      });
+      return key;
+    })()
+  `);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create CryptoKey instance: ${JSON.stringify(err)}`);
+  }
+  return result.value;
+}
+function createCryptoKeyPairInstance(context, keyPair) {
+  const publicKeyHandle = createCryptoKeyInstance(context, keyPair.publicKey);
+  const privateKeyHandle = createCryptoKeyInstance(context, keyPair.privateKey);
+  const obj = context.newObject();
+  context.setProp(obj, "publicKey", publicKeyHandle);
+  context.setProp(obj, "privateKey", privateKeyHandle);
+  publicKeyHandle.dispose();
+  privateKeyHandle.dispose();
+  return obj;
+}
+function getHostKey(context, keyHandle) {
+  const instanceIdHandle = context.getProp(keyHandle, "__instanceId__");
+  if (context.typeof(instanceIdHandle) !== "number") {
+    instanceIdHandle.dispose();
+    throw new Error("Invalid CryptoKey: missing __instanceId__");
+  }
+  const instanceId = context.getNumber(instanceIdHandle);
+  instanceIdHandle.dispose();
+  const state = getInstanceStateById(instanceId);
+  if (!state) {
+    throw new Error("Invalid CryptoKey: state not found");
+  }
+  return state.hostKey;
+}
+function getArg(args, index) {
+  const arg = args[index];
+  if (!arg) {
+    throw new Error(`Missing argument at index ${index}`);
+  }
+  return arg;
+}
+function createSubtleMethod(context, methodName, unmarshalArgs, implementation) {
+  return context.newFunction(methodName, (...args) => {
+    const deferred = context.newPromise();
+    let unmarshaledArgs;
+    try {
+      unmarshaledArgs = unmarshalArgs(context, args);
+    } catch (error) {
+      const errorHandle = marshal(context, {
+        name: error instanceof Error ? error.name : "Error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      deferred.reject(errorHandle);
+      errorHandle.dispose();
+      context.runtime.executePendingJobs();
+      return deferred.handle;
+    }
+    Promise.resolve().then(async () => {
+      try {
+        const resultHandle = await implementation(context, unmarshaledArgs);
+        deferred.resolve(resultHandle);
+        resultHandle.dispose();
+      } catch (error) {
+        const errorHandle = marshal(context, {
+          name: error instanceof Error ? error.name : "Error",
+          message: error instanceof Error ? error.message : String(error)
+        });
+        deferred.reject(errorHandle);
+        errorHandle.dispose();
+      }
+      context.runtime.executePendingJobs();
+    });
+    return deferred.handle;
+  });
+}
+function createSubtleCryptoObject(context) {
+  const subtle = context.newObject();
+  const digestFn = createSubtleMethod(context, "digest", (ctx, args) => ({
+    algorithm: unmarshal(ctx, getArg(args, 0)),
+    data: unmarshal(ctx, getArg(args, 1))
+  }), async (ctx, { algorithm, data }) => {
+    const result = await crypto.subtle.digest(algorithm, data);
+    return marshal(ctx, new Uint8Array(result));
+  });
+  context.setProp(subtle, "digest", digestFn);
+  digestFn.dispose();
+  const generateKeyFn = createSubtleMethod(context, "generateKey", (ctx, args) => ({
+    algorithm: unmarshal(ctx, getArg(args, 0)),
+    extractable: unmarshal(ctx, getArg(args, 1)),
+    keyUsages: unmarshal(ctx, getArg(args, 2))
+  }), async (ctx, { algorithm, extractable, keyUsages }) => {
+    const result = await crypto.subtle.generateKey(algorithm, extractable, keyUsages);
+    if ("publicKey" in result && "privateKey" in result) {
+      return createCryptoKeyPairInstance(ctx, result);
+    } else {
+      return createCryptoKeyInstance(ctx, result);
+    }
+  });
+  context.setProp(subtle, "generateKey", generateKeyFn);
+  generateKeyFn.dispose();
+  const signFn = createSubtleMethod(context, "sign", (ctx, args) => ({
+    algorithm: unmarshal(ctx, getArg(args, 0)),
+    key: getHostKey(ctx, getArg(args, 1)),
+    data: unmarshal(ctx, getArg(args, 2))
+  }), async (ctx, { algorithm, key, data }) => {
+    const result = await crypto.subtle.sign(algorithm, key, data);
+    return marshal(ctx, new Uint8Array(result));
+  });
+  context.setProp(subtle, "sign", signFn);
+  signFn.dispose();
+  const verifyFn = createSubtleMethod(context, "verify", (ctx, args) => ({
+    algorithm: unmarshal(ctx, getArg(args, 0)),
+    key: getHostKey(ctx, getArg(args, 1)),
+    signature: unmarshal(ctx, getArg(args, 2)),
+    data: unmarshal(ctx, getArg(args, 3))
+  }), async (ctx, { algorithm, key, signature, data }) => {
+    const result = await crypto.subtle.verify(algorithm, key, signature, data);
+    return marshal(ctx, result);
+  });
+  context.setProp(subtle, "verify", verifyFn);
+  verifyFn.dispose();
+  const encryptFn = createSubtleMethod(context, "encrypt", (ctx, args) => ({
+    algorithm: unmarshal(ctx, getArg(args, 0)),
+    key: getHostKey(ctx, getArg(args, 1)),
+    data: unmarshal(ctx, getArg(args, 2))
+  }), async (ctx, { algorithm, key, data }) => {
+    const result = await crypto.subtle.encrypt(algorithm, key, data);
+    return marshal(ctx, new Uint8Array(result));
+  });
+  context.setProp(subtle, "encrypt", encryptFn);
+  encryptFn.dispose();
+  const decryptFn = createSubtleMethod(context, "decrypt", (ctx, args) => ({
+    algorithm: unmarshal(ctx, getArg(args, 0)),
+    key: getHostKey(ctx, getArg(args, 1)),
+    data: unmarshal(ctx, getArg(args, 2))
+  }), async (ctx, { algorithm, key, data }) => {
+    const result = await crypto.subtle.decrypt(algorithm, key, data);
+    return marshal(ctx, new Uint8Array(result));
+  });
+  context.setProp(subtle, "decrypt", decryptFn);
+  decryptFn.dispose();
+  const importKeyFn = createSubtleMethod(context, "importKey", (ctx, args) => ({
+    format: unmarshal(ctx, getArg(args, 0)),
+    keyData: unmarshal(ctx, getArg(args, 1)),
+    algorithm: unmarshal(ctx, getArg(args, 2)),
+    extractable: unmarshal(ctx, getArg(args, 3)),
+    keyUsages: unmarshal(ctx, getArg(args, 4))
+  }), async (ctx, { format, keyData, algorithm, extractable, keyUsages }) => {
+    let result;
+    if (format === "jwk") {
+      result = await crypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages);
+    } else {
+      let data;
+      if (keyData instanceof Uint8Array) {
+        data = keyData.buffer.slice(keyData.byteOffset, keyData.byteOffset + keyData.byteLength);
+      } else {
+        data = keyData;
+      }
+      result = await crypto.subtle.importKey(format, data, algorithm, extractable, keyUsages);
+    }
+    return createCryptoKeyInstance(ctx, result);
+  });
+  context.setProp(subtle, "importKey", importKeyFn);
+  importKeyFn.dispose();
+  const exportKeyFn = createSubtleMethod(context, "exportKey", (ctx, args) => ({
+    format: unmarshal(ctx, getArg(args, 0)),
+    key: getHostKey(ctx, getArg(args, 1))
+  }), async (ctx, { format, key }) => {
+    const result = await crypto.subtle.exportKey(format, key);
+    if (result instanceof ArrayBuffer) {
+      return marshal(ctx, new Uint8Array(result));
+    } else {
+      return marshal(ctx, result);
+    }
+  });
+  context.setProp(subtle, "exportKey", exportKeyFn);
+  exportKeyFn.dispose();
+  const deriveBitsFn = createSubtleMethod(context, "deriveBits", (ctx, args) => {
+    const algorithmRaw = unmarshal(ctx, getArg(args, 0));
+    const baseKey = getHostKey(ctx, getArg(args, 1));
+    const length = unmarshal(ctx, getArg(args, 2));
+    let algorithm = algorithmRaw;
+    if (algorithmRaw.public && typeof algorithmRaw.public === "object") {
+      const publicKeyData = algorithmRaw.public;
+      if (publicKeyData.__instanceId__ !== undefined) {
+        const publicKeyState = getInstanceStateById(publicKeyData.__instanceId__);
+        if (publicKeyState) {
+          algorithm = { ...algorithmRaw, public: publicKeyState.hostKey };
+        }
+      }
+    }
+    return { algorithm, baseKey, length };
+  }, async (ctx, { algorithm, baseKey, length }) => {
+    const result = await crypto.subtle.deriveBits(algorithm, baseKey, length);
+    return marshal(ctx, new Uint8Array(result));
+  });
+  context.setProp(subtle, "deriveBits", deriveBitsFn);
+  deriveBitsFn.dispose();
+  const deriveKeyFn = createSubtleMethod(context, "deriveKey", (ctx, args) => {
+    const algorithmRaw = unmarshal(ctx, getArg(args, 0));
+    const baseKey = getHostKey(ctx, getArg(args, 1));
+    const derivedKeyType = unmarshal(ctx, getArg(args, 2));
+    const extractable = unmarshal(ctx, getArg(args, 3));
+    const keyUsages = unmarshal(ctx, getArg(args, 4));
+    let algorithm = algorithmRaw;
+    if (algorithmRaw.public && typeof algorithmRaw.public === "object") {
+      const publicKeyData = algorithmRaw.public;
+      if (publicKeyData.__instanceId__ !== undefined) {
+        const publicKeyState = getInstanceStateById(publicKeyData.__instanceId__);
+        if (publicKeyState) {
+          algorithm = { ...algorithmRaw, public: publicKeyState.hostKey };
+        }
+      }
+    }
+    return { algorithm, baseKey, derivedKeyType, extractable, keyUsages };
+  }, async (ctx, { algorithm, baseKey, derivedKeyType, extractable, keyUsages }) => {
+    const result = await crypto.subtle.deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages);
+    return createCryptoKeyInstance(ctx, result);
+  });
+  context.setProp(subtle, "deriveKey", deriveKeyFn);
+  deriveKeyFn.dispose();
+  const wrapKeyFn = createSubtleMethod(context, "wrapKey", (ctx, args) => ({
+    format: unmarshal(ctx, getArg(args, 0)),
+    key: getHostKey(ctx, getArg(args, 1)),
+    wrappingKey: getHostKey(ctx, getArg(args, 2)),
+    wrapAlgorithm: unmarshal(ctx, getArg(args, 3))
+  }), async (ctx, { format, key, wrappingKey, wrapAlgorithm }) => {
+    const result = await crypto.subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm);
+    return marshal(ctx, new Uint8Array(result));
+  });
+  context.setProp(subtle, "wrapKey", wrapKeyFn);
+  wrapKeyFn.dispose();
+  const unwrapKeyFn = createSubtleMethod(context, "unwrapKey", (ctx, args) => ({
+    format: unmarshal(ctx, getArg(args, 0)),
+    wrappedKey: unmarshal(ctx, getArg(args, 1)),
+    unwrappingKey: getHostKey(ctx, getArg(args, 2)),
+    unwrapAlgorithm: unmarshal(ctx, getArg(args, 3)),
+    unwrappedKeyAlgorithm: unmarshal(ctx, getArg(args, 4)),
+    extractable: unmarshal(ctx, getArg(args, 5)),
+    keyUsages: unmarshal(ctx, getArg(args, 6))
+  }), async (ctx, { format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages }) => {
+    const result = await crypto.subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages);
+    return createCryptoKeyInstance(ctx, result);
+  });
+  context.setProp(subtle, "unwrapKey", unwrapKeyFn);
+  unwrapKeyFn.dispose();
+  return subtle;
+}
+export {
+  createSubtleCryptoObject,
+  createCryptoKeyInstance
+};
+
+//# debugId=447E4B44811F04E864756E2164756E21