@canonmsg/agent-sdk 12.4.1 → 12.6.1

package/dist/internal/endpoint/node-mls-custody-protocol.d.ts

@@ -23,6 +23,11 @@ export declare function requireValue(value: unknown): asserts value;
 export declare function record(value: unknown, fields: string[]): Record<string, unknown>;
 export declare function sealed(value: unknown, maximum: number, nullable?: boolean): string | null;
 export declare function frame(operation: number, values: readonly (string | null)[]): Buffer;
+/** What `frame` wrote: its operation and arguments. */
+export declare function parseFrame(input: Buffer): {
+    operation: number;
+    values: (string | null)[];
+};
 /** JSON.parse supplies grammar validation; this pass rejects duplicate object
  * names (including escaped aliases) before the closed contract parsers run. */
 export declare function parseJson(bytes: Buffer): unknown;

package/dist/internal/endpoint/node.d.ts

@@ -5,3 +5,4 @@ export declare function createNodeEndpointStore(options: {
 }): Promise<EndpointStore>;
 export { createNodeMlsDevCustody, NodeMlsDevCustodyError, type NodeMlsDevCustody, type NodeMlsDevCustodyOptions } from './node-mls-custody.js';
 export { createPortableNodeMlsDevCustody, type PortableNodeMlsDevCustody, type PortableNodeMlsDevCustodyOptions } from './portable-node-mls-custody.js';
+export { custodyFailure, custodyValue, frame, MAX_INPUT, MAX_OUTPUT, parseFrame, rejected, requireValue, typedNodeMlsDevCustody } from './node-mls-custody-protocol.js';

package/dist/media.js

@@ -18,8 +18,10 @@ import {
   toAnthropicImageBlock,
   toAnthropicImageBlocksWithinBudget,
   uploadMediaFile
-} from "./chunks/chunk-6PKXASSK.js";
-import "./chunks/chunk-GWQF4WFT.js";
+} from "./chunks/chunk-5J4YPLNW.js";
+import "./chunks/chunk-FVYKLH6I.js";
+import "./chunks/chunk-QK37HAHC.js";
+import "./chunks/chunk-S7BV74DN.js";
 export {
   DEFAULT_ANTHROPIC_REQUEST_HEADROOM_BYTES,
   DEFAULT_MEDIA_CACHE_DIR,

package/dist/mls/wasm/canon_mls_wasm.js

@@ -0,0 +1,363 @@
+/* @ts-self-types="./canon_mls_wasm.d.ts" */
+
+/**
+ * @returns {number}
+ */
+export function abi_version() {
+    const ret = wasm.abi_version();
+    return ret >>> 0;
+}
+
+/**
+ * @param {Uint8Array} identity_context
+ * @param {Uint8Array} group_context
+ * @param {Uint8Array} command
+ * @param {Uint8Array} identity_state
+ * @param {Uint8Array | null | undefined} group_state
+ * @param {Uint8Array | null | undefined} key_package_state
+ * @param {Uint8Array} issuer_keys
+ * @param {Uint8Array} receipt_keys
+ * @param {number} now_ms
+ * @returns {Uint8Array}
+ */
+export function prepare_group(identity_context, group_context, command, identity_state, group_state, key_package_state, issuer_keys, receipt_keys, now_ms) {
+    const ptr0 = passArray8ToWasm0(identity_context, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(group_context, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(command, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray8ToWasm0(identity_state, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    var ptr4 = isLikeNone(group_state) ? 0 : passArray8ToWasm0(group_state, wasm.__wbindgen_malloc);
+    var len4 = WASM_VECTOR_LEN;
+    var ptr5 = isLikeNone(key_package_state) ? 0 : passArray8ToWasm0(key_package_state, wasm.__wbindgen_malloc);
+    var len5 = WASM_VECTOR_LEN;
+    const ptr6 = passArray8ToWasm0(issuer_keys, wasm.__wbindgen_malloc);
+    const len6 = WASM_VECTOR_LEN;
+    const ptr7 = passArray8ToWasm0(receipt_keys, wasm.__wbindgen_malloc);
+    const len7 = WASM_VECTOR_LEN;
+    const ret = wasm.prepare_group(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, now_ms);
+    var v9 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v9;
+}
+
+/**
+ * @param {Uint8Array} context
+ * @param {Uint8Array} command
+ * @param {Uint8Array} identity_state
+ * @param {Uint8Array} issuer_keys
+ * @param {number} now_ms
+ * @returns {Uint8Array}
+ */
+export function prepare_key_package(context, command, identity_state, issuer_keys, now_ms) {
+    const ptr0 = passArray8ToWasm0(context, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(command, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(identity_state, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray8ToWasm0(issuer_keys, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.prepare_key_package(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, now_ms);
+    var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v5;
+}
+
+/**
+ * @param {Uint8Array} context
+ * @param {Uint8Array} command
+ * @param {Uint8Array | null | undefined} state
+ * @param {number} now_ms
+ * @returns {Uint8Array}
+ */
+export function prepare_signing(context, command, state, now_ms) {
+    const ptr0 = passArray8ToWasm0(context, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(command, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(state) ? 0 : passArray8ToWasm0(state, wasm.__wbindgen_malloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.prepare_signing(ptr0, len0, ptr1, len1, ptr2, len2, now_ms);
+    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v4;
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_90b56bc79aad6f6c: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
+        __wbg_getRandomValues_436a51d0629d84e1: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_length_7f3c00c40364105e: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
+        __wbg_new_with_length_3da0ad195f6f63ba: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
+        __wbg_now_aa4ccb83129e9e55: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
+        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
+        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_subarray_002b94d5e13d1411: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./canon_mls_wasm_bg.js": import0,
+    };
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('canon_mls_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/dist/mls-wasm-host.js

@@ -0,0 +1,258 @@
+import {
+  WASM_HOST_CONFIGURE,
+  WASM_HOST_PROVISION,
+  keyFile
+} from "./chunks/chunk-HH7KR22P.js";
+import {
+  MAX_INPUT,
+  NodeMlsDevCustodyError,
+  parseFrame,
+  rejected,
+  requireValue
+} from "./chunks/chunk-FVYKLH6I.js";
+import {
+  __name,
+  canonicalEndpointJson,
+  isMlsDevReceiptClockSkew,
+  parseMlsDevDeviceContext
+} from "./chunks/chunk-S7BV74DN.js";
+
+// src/mls-wasm-host.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+
+// ../endpoint/src/mls-browser-custody.ts
+var AAD_DOMAIN = "canon.mls.browser-state.v1";
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var MAX_PAYLOAD_BYTES = 4 * 1024 * 1024;
+var refused = /* @__PURE__ */ __name(() => {
+  throw new Error("CANON_MLS_CUSTODY_REFUSED");
+}, "refused");
+function toBase64(bytes) {
+  let text = "";
+  for (let at = 0; at < bytes.length; at += 32768) text += String.fromCharCode(...bytes.subarray(at, at + 32768));
+  return btoa(text);
+}
+__name(toBase64, "toBase64");
+function fromBase64(text) {
+  const binary = atob(text), bytes = new Uint8Array(binary.length);
+  for (let at = 0; at < binary.length; at += 1) bytes[at] = binary.charCodeAt(at);
+  return bytes;
+}
+__name(fromBase64, "fromBase64");
+function parsedContext(json) {
+  const { revision, ...context } = JSON.parse(json);
+  if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0) refused();
+  return { contextId: canonicalEndpointJson(context), context, revision };
+}
+__name(parsedContext, "parsedContext");
+function createMlsBrowserCustody(options) {
+  const { engine, wrappingKey } = options;
+  const clock = options.clock ?? Date.now;
+  const issuerKeys = encoder.encode(JSON.stringify(options.issuerKeys)), receiptKeys = encoder.encode(JSON.stringify(options.receiptKeys));
+  const aad = /* @__PURE__ */ __name((purpose, context, binding) => encoder.encode(canonicalEndpointJson({ domain: AAD_DOMAIN, purpose, context, binding })), "aad");
+  async function wrap(key, additionalData, clear) {
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const sealed = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData }, key, clear));
+    const framed = new Uint8Array(12 + sealed.length);
+    framed.set(iv);
+    framed.set(sealed, 12);
+    return `v1:${toBase64(framed)}`;
+  }
+  __name(wrap, "wrap");
+  async function unwrap(key, additionalData, wrapped) {
+    if (!wrapped.startsWith("v1:")) refused();
+    const framed = fromBase64(wrapped.slice(3));
+    if (framed.length < 28) refused();
+    return new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv: framed.subarray(0, 12), additionalData }, key, framed.subarray(12)));
+  }
+  __name(unwrap, "unwrap");
+  function answer2(bytes) {
+    if (bytes.length < 4) refused();
+    const length = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0);
+    if (length === 0) return { skew: decoder.decode(bytes.subarray(4)) };
+    if (length > MAX_PAYLOAD_BYTES || length > bytes.length - 4) refused();
+    return { payload: decoder.decode(bytes.subarray(4, 4 + length)), clear: bytes.slice(4 + length) };
+  }
+  __name(answer2, "answer");
+  async function finish(bytes, seal) {
+    try {
+      const result = answer2(bytes);
+      if ("skew" in result) return result.skew;
+      try {
+        return `{"wrappedState":${JSON.stringify(await seal(result.clear, result.payload))},"payload":${result.payload}}`;
+      } finally {
+        result.clear.fill(0);
+      }
+    } finally {
+      bytes.fill(0);
+    }
+  }
+  __name(finish, "finish");
+  return Object.freeze({
+    async initializeDevSigning(contextJson) {
+      await wrappingKey(parsedContext(contextJson).contextId);
+    },
+    async prepareDevSigning(contextJson, commandJson, wrappedState) {
+      const { contextId, context, revision } = parsedContext(contextJson), key = await wrappingKey(contextId);
+      const clear = wrappedState === null ? void 0 : await unwrap(key, aad("identity", context, { revision }), wrappedState);
+      try {
+        const prepared2 = engine.prepare_signing(encoder.encode(contextJson), encoder.encode(commandJson), clear, clock());
+        return await finish(prepared2, (next) => wrap(key, aad("identity", context, { revision: revision + 1 }), next));
+      } finally {
+        clear?.fill(0);
+      }
+    },
+    async prepareDevKeyPackage(contextJson, commandJson, wrappedIdentityState) {
+      const { contextId, context, revision } = parsedContext(contextJson), key = await wrappingKey(contextId);
+      const identity2 = await unwrap(key, aad("identity", context, { revision }), wrappedIdentityState);
+      try {
+        const prepared2 = engine.prepare_key_package(encoder.encode(contextJson), encoder.encode(commandJson), identity2, issuerKeys, clock());
+        return await finish(prepared2, (next, payload) => {
+          const { keyPackageId, deviceId } = JSON.parse(payload);
+          return wrap(key, aad("key-package", context, { version: 1, keyPackageId, deviceId }), next);
+        });
+      } finally {
+        identity2.fill(0);
+      }
+    },
+    async prepareDevGroup(identityContextJson, groupContextJson, commandJson, wrappedIdentityState, wrappedGroupState, wrappedKeyPackageState) {
+      const { contextId, context, revision } = parsedContext(identityContextJson), key = await wrappingKey(contextId);
+      const group = JSON.parse(groupContextJson);
+      const clear = [];
+      const open = /* @__PURE__ */ __name(async (additionalData, wrapped) => {
+        const opened = await unwrap(key, additionalData, wrapped);
+        clear.push(opened);
+        return opened;
+      }, "open");
+      try {
+        const identity2 = await open(aad("identity", context, { revision }), wrappedIdentityState);
+        const groupState = wrappedGroupState === null ? void 0 : await open(aad("group", context, group), wrappedGroupState);
+        let keyPackageState;
+        if (wrappedKeyPackageState !== null) {
+          const { keyPackageId } = JSON.parse(commandJson);
+          keyPackageState = await open(aad("key-package", context, { version: 1, keyPackageId, deviceId: group.deviceId }), wrappedKeyPackageState);
+        }
+        const prepared2 = engine.prepare_group(
+          encoder.encode(identityContextJson),
+          encoder.encode(groupContextJson),
+          encoder.encode(commandJson),
+          identity2,
+          groupState,
+          keyPackageState,
+          issuerKeys,
+          receiptKeys,
+          clock()
+        );
+        return await finish(prepared2, (next) => wrap(key, aad("group", context, { ...group, revision: group.revision + 1 }), next));
+      } finally {
+        clear.forEach((bytes) => bytes.fill(0));
+      }
+    }
+  });
+}
+__name(createMlsBrowserCustody, "createMlsBrowserCustody");
+
+// src/mls-wasm-host.ts
+var NULL = Buffer.from('{"version":1,"ok":true,"value":null}');
+var REJECTED = Buffer.from('{"version":1,"ok":false,"error":"MLS_NODE_CUSTODY_REJECTED"}');
+var sha256 = /* @__PURE__ */ __name((bytes) => createHash("sha256").update(bytes).digest("hex"), "sha256");
+var prepared = /* @__PURE__ */ __name((value) => Buffer.from(isMlsDevReceiptClockSkew(JSON.parse(value)) ? value : `{"version":1,"ok":true,"value":${value}}`), "prepared");
+var configuration;
+var custody;
+var wrapping;
+async function load() {
+  requireValue(existsSync(configuration.keyPath));
+  const bytes = keyFile(configuration.keyPath);
+  try {
+    return await crypto.subtle.importKey("raw", bytes, "AES-GCM", false, ["encrypt", "decrypt"]);
+  } finally {
+    bytes.fill(0);
+  }
+}
+__name(load, "load");
+async function configure(value) {
+  const wasm = readFileSync(value.wasmPath), glue = readFileSync(value.gluePath);
+  requireValue(sha256(wasm) === value.wasmSha256 && sha256(glue) === value.glueSha256);
+  const engine = await import(`data:text/javascript;base64,${glue.toString("base64")}`);
+  engine.initSync({ module: wasm });
+  configuration = value;
+  custody = createMlsBrowserCustody({
+    engine,
+    issuerKeys: value.issuerKeys,
+    receiptKeys: value.receiptKeys,
+    wrappingKey: /* @__PURE__ */ __name(() => wrapping ??= load().catch((error) => {
+      wrapping = void 0;
+      throw error;
+    }), "wrappingKey")
+  });
+}
+__name(configure, "configure");
+var identity = /* @__PURE__ */ __name((value) => {
+  const { revision: _revision, ...device } = parseMlsDevDeviceContext(value);
+  return JSON.stringify(device);
+}, "identity");
+function own(value) {
+  requireValue(typeof value === "string" && configuration);
+  requireValue(identity(JSON.parse(value)) === identity({ ...configuration.context, revision: 0 }));
+  return value;
+}
+__name(own, "own");
+async function answer(operation, values) {
+  if (operation === WASM_HOST_CONFIGURE) {
+    requireValue(!custody && values.length === 1);
+    await configure(JSON.parse(values[0]));
+    return NULL;
+  }
+  const context = own(values[0]);
+  if (operation === WASM_HOST_PROVISION) {
+    requireValue(values.length === 1 && !existsSync(configuration.keyPath));
+    keyFile(configuration.keyPath).fill(0);
+    return NULL;
+  }
+  if (operation === 1 && values.length === 1) {
+    await custody.initializeDevSigning(context);
+    return NULL;
+  }
+  if (operation === 2 && values.length === 3) return prepared(await custody.prepareDevSigning(context, values[1], values[2]));
+  if (operation === 3 && values.length === 3) return prepared(await custody.prepareDevKeyPackage(context, values[1], values[2]));
+  if (operation === 4 && values.length === 6) {
+    return prepared(await custody.prepareDevGroup(context, values[1], values[2], values[3], values[4], values[5]));
+  }
+  return rejected();
+}
+__name(answer, "answer");
+async function* frames(input) {
+  let buffered = Buffer.alloc(0);
+  for await (const chunk of input) {
+    buffered = Buffer.concat([buffered, chunk]);
+    while (buffered.length >= 4) {
+      const length = buffered.readUInt32BE(0);
+      requireValue(length <= MAX_INPUT);
+      if (buffered.length < 4 + length) break;
+      yield buffered.subarray(4, 4 + length);
+      buffered = buffered.subarray(4 + length);
+    }
+  }
+}
+__name(frames, "frames");
+function send(message) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(message.length);
+  return new Promise((sent) => {
+    process.stdout.write(Buffer.concat([length, message]), () => sent());
+  });
+}
+__name(send, "send");
+for (const signal of ["SIGINT", "SIGTERM", "SIGBREAK", "SIGHUP"]) process.on(signal, () => void 0);
+for await (const message of frames(process.stdin)) {
+  try {
+    const { operation, values } = parseFrame(message);
+    await send(await answer(operation, values));
+  } catch (error) {
+    if (!custody || !(error instanceof NodeMlsDevCustodyError) && error.message !== "CANON_MLS_CUSTODY_REFUSED") process.exit(70);
+    await send(REJECTED);
+  }
+}
+process.exit(0);

package/dist/runner/mls-bundled.d.ts

@@ -16,10 +16,23 @@ export declare const MLS_ENVIRONMENT_PINS: Readonly<Record<MlsEnvironmentId, {
 }>>;
 /**
  * The custody helper this package ships for this host (`dist/mls/<platform>/canon-mls-custody`), checked against its
- * pin, or undefined where it ships none: an Intel Mac, musl, Windows, or a build of this package without helpers. A
- * file that is there but differs from its pin is refused.
+ * pin, or undefined where it ships none that runs: an Intel Mac, Windows, musl, an old glibc, or a build of this package
+ * without helpers. A file that is there but differs from its pin is refused.
  */
 export declare function bundledMlsCustodyHelper(): {
     path: string;
     sha256: string;
 } | undefined;
+export interface BundledMlsWasmCore {
+    /** The process that runs the core (dist/mls-wasm-host.js). */
+    hostPath: string;
+    wasmPath: string;
+    wasmSha256: string;
+    gluePath: string;
+    glueSha256: string;
+}
+/**
+ * The WASM core this package ships for hosts with no helper (`dist/mls/wasm/`), checked against its pins, or undefined in a
+ * build of this package without it. A file that is there but differs from its pin is refused.
+ */
+export declare function bundledMlsWasmCore(): BundledMlsWasmCore | undefined;