@canonmsg/agent-sdk 12.5.1 → 13.0.2

package/dist/internal/core/retry.d.ts

@@ -1,82 +1,12 @@
-import type { SendMessageOptions } from './types.js';
-import { type CanonClient } from './client.js';
-export interface SendMessageRetryOptions {
-    /** Stable replacement recorded by the product after a conclusive rejection. */
-    operationId?: string;
-    replacesOperationId?: string;
-    signal?: AbortSignal;
-    timeoutMs?: number;
-    maxAttempts?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    sleep?: (ms: number) => Promise<void>;
-}
 export declare const CANON_MESSAGE_TEXT_MAX_BYTES: number;
 export declare const DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES = 3800;
-export interface SendMessageChunkingOptions {
-    maxTextBytes?: number;
-    /**
-     * Opt in to resumable chunked delivery.
-     *
-     * With it on, a mid-sequence failure throws a `ChunkedSendMessageError`
-     * carrying the ids of the parts that ARE durable, so a later attempt can pick
-     * up the tail. Off by default so callers that do not resume keep today's
-     * behaviour: the raw send error, unwrapped.
-     *
-     * Implied by a non-empty `deliveredMessageIds` — passing progress back IS
-     * opting in.
-     */
-    resumable?: boolean;
-    /**
-     * Ids of the parts an earlier attempt already made durable, in part order.
-     * Those parts are skipped and their ids are carried into the result, so a
-     * resumed send still reports the whole answer.
-     */
-    deliveredMessageIds?: readonly string[];
-}
-export interface ChunkedSendMessageResult {
-    messageIds: string[];
-}
 /** Pending delivery is visible, but cannot truthfully produce a failure notice. */
 export declare function isPendingCanonOperation(error: unknown): boolean;
-/**
- * A chunked send that stopped part-way, with the progress needed to resume it.
- *
- * Parts 1..`deliveredMessageIds.length` are durable in Canon; only the tail is
- * missing. Handing `deliveredMessageIds` back to `sendMessageWithRetryChunked`
- * restarts at the next part instead of re-sending the answer's head — which the
- * server would reject or duplicate, and which the reader has already seen.
- */
-export declare class ChunkedSendMessageError extends Error {
-    /** Ids of the parts that are durable in Canon, in part order. */
-    readonly deliveredMessageIds: string[];
-    /** The part the send stopped on (1-based). */
-    readonly failedPart: number;
-    /** How many parts the text splits into in total. */
-    readonly totalParts: number;
-    /** The underlying send failure — what callers should classify. */
-    readonly cause: unknown;
-    constructor(input: {
-        cause: unknown;
-        deliveredMessageIds: readonly string[];
-        failedPart: number;
-        totalParts: number;
-    });
-    /** How many parts are durable — a resume starts at the next one. */
-    get deliveredParts(): number;
-}
-/**
- * Structural check as well as `instanceof`, so progress survives a caller that
- * ended up with a second copy of this module (a workspace package resolved to
- * both `dist` and source, say) instead of silently degrading to "no progress".
- */
-export declare function isChunkedSendMessageError(error: unknown): error is ChunkedSendMessageError;
 export declare function isRetryableCanonDeliveryError(error: unknown): boolean;
-export declare function sendMessageWithRetry(client: CanonClient, conversationId: string, text: string, options?: SendMessageOptions, retryOptions?: SendMessageRetryOptions): Promise<{
-    messageId: string;
-}>;
 export declare function utf8ByteLength(value: string): number;
 export declare function splitTextByUtf8Bytes(text: string, maxBytes?: number): string[];
+/** The same split for a limit of the caller's own: an encrypted room's text takes up to 32 KiB. */
+export declare function splitTextWithinBytes(text: string, byteLimit: number): string[];
 export declare function chunkMessageId(baseMessageId: string | undefined, index: number): string | undefined;
 export interface ChunkedMessagePartMetadataInput {
     /** Stable group id shared by every part, normally the unsuffixed message id. */
@@ -94,20 +24,3 @@ export interface ChunkedMessagePartMetadataInput {
  * preceding message parts.
  */
 export declare function buildChunkedMessagePartMetadata(input: ChunkedMessagePartMetadataInput): Record<string, unknown>;
-/**
- * Send `text` as one message, or as an ordered sequence of `-part-N` messages
- * when it exceeds the byte budget.
- *
- * Sequential by construction, so a failure leaves parts 1..k durable and the
- * tail unsent. Callers that opt into `resumable` get that progress back (see
- * `ChunkedSendMessageError`) and can hand it to a later attempt, which then
- * picks up at part k+1. The split is a pure function of the text and the byte
- * budget, so part N of a resumed attempt is byte-identical to part N of the
- * attempt that delivered it — which is what makes the `-part-N` ids a safe
- * resume cursor.
- *
- * A byte-identical replay succeeds at the server. Any idempotency conflict
- * therefore means the stored part differs and is always reported; treating it
- * as delivered would stitch two different answers together.
- */
-export declare function sendMessageWithRetryChunked(client: CanonClient, conversationId: string, text: string, options?: SendMessageOptions, retryOptions?: SendMessageRetryOptions, chunkingOptions?: SendMessageChunkingOptions): Promise<ChunkedSendMessageResult>;

package/dist/internal/core/silent-turn.d.ts

@@ -11,39 +11,10 @@
  * the server and the hosts depend on.
  */
 export { NO_REPLY_ACK_NOTE } from '../backend-contracts/index.js';
-import { type CanonVerbWireRequest } from '../backend-contracts/index.js';
-/** The one client capability the outcome report needs. */
-export interface NoReplyReportClient {
-    executeVerbWire(wire: CanonVerbWireRequest): Promise<unknown>;
-}
 /**
- * What `reportNoReplyOutcome` puts on the wire in place of any caller-supplied
- * reason text. The server stores only `hasReason` and discards the text, so
- * transmitting the model- or handler-authored sentence would be pure exposure:
- * the sentinel preserves the server's `hasReason` signal without moving the
- * text. The reason a binding was handed never leaves its process.
+ * What a `no_reply` verb carries in place of any caller-supplied reason text.
+ * The server stores only `hasReason` and discards the text, so transmitting
+ * the model- or handler-authored sentence would be pure exposure: the sentinel
+ * preserves the server's `hasReason` signal without moving the text.
  */
 export declare const NO_REPLY_REASON_SENTINEL = "given";
-/**
- * Report a locally-answered `no_reply` to the server, fire-and-forget.
- *
- * Four of the five runtimes answer the silence tool inside their own process
- * and never reach `POST /agent/verbs/no_reply`, so Canon's durable record of
- * deliberate silence (`/runtime-silence/{convoId}/{agentId}`) would otherwise
- * cover Claude turns only. This is telemetry, not behavior: the silence flag
- * is already set locally before this is called, so a failed or unreachable
- * report degrades to exactly the pre-report behavior — never to a posted
- * message and never to a failed turn.
- *
- * `params.reason` is read only for its presence: the wire carries
- * `NO_REPLY_REASON_SENTINEL` in its place, never the caller's text.
- *
- * The Claude host must NOT call this helper: its binding already POSTs the
- * verb via agent-tools, so calling both would double-record the silence.
- */
-export declare function reportNoReplyOutcome(client: NoReplyReportClient, params: {
-    conversationId: string;
-    messageId?: string;
-    reason?: string;
-    now?: number;
-}): void;

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

@@ -34,6 +34,9 @@ export interface EndpointExecuteOptions {
     operationId?: string;
     sensitive?: boolean;
     guardId?: string;
+    /** A person's text in an encrypted room that is held (D2): kept on this device and sent once the room may send, the
+     * call waiting with it, instead of refused with `MLS_DEV_GROUP_ADMISSION_PENDING`. */
+    waitWhileHeld?: boolean;
 }
 export interface EndpointWaitOptions {
     signal?: AbortSignal;
@@ -132,6 +135,9 @@ export interface EndpointOptions {
     autoDrain?: boolean;
     /** Explicit synthetic Dev device identity operations, using this endpoint's store and lifecycle. */
     mlsDevDevice?: MlsDevDeviceClientOptions;
+    /** A person's inbox rows show each encrypted room's last message from this device's copy. Never set for an agent: an
+     * inbox read can serve a turn from someone outside that room. */
+    localInboxPreviews?: boolean;
 }
 export type EndpointContentMode = 'plaintext' | 'mls-dev-text' | 'mls-required';
 export interface Endpoint {

package/dist/internal/endpoint/mls-dev-client.d.ts

@@ -37,6 +37,8 @@ export interface MlsDevDeviceClient {
      * to a room, and readiness refuses it. A device Canon never registered has
      * nothing to revoke; a revoked one is returned as it is. Rooms keep its leaf until Canon can remove devices (step 5c). */
     revoke(): Promise<MlsDevDeviceView>;
+    /** Logs out another of this account's devices (its device list); this one leaves through `revoke`. */
+    revokeOther(deviceId: string): Promise<void>;
 }
 /** Whether readiness would renew this registered device: it has no credential, or less than half its lifetime remains. */
 export declare function isMlsDevCredentialRenewalDue(view: MlsDevDeviceView, now: number): boolean;

package/dist/internal/endpoint/mls-dev-groups.d.ts

@@ -46,6 +46,8 @@ export interface MlsDevVerifiedMessageBinding {
 export interface MlsDevAdmissionHold {
     readonly held: boolean;
     readonly waitingPrincipalIds: readonly string[];
+    /** This device joined after the room's first message, so its history starts later (mls-rooms-by-default.md §2.7). */
+    readonly missedEarlier?: true;
 }
 export interface MlsDevCurrentAudience {
     readonly version: 1;
@@ -173,6 +175,16 @@ export declare function createMlsDevGroups(options: MlsDevDeviceClientOptions, c
      * encrypted room (mls-payload-v3.md §4). Items and cards are not forwarded yet. */
     forwardText(value: unknown, operationId: string, guardId?: string): Promise<EndpointOperation>;
     sendText(value: unknown, operationId: string, guardId?: string): Promise<EndpointOperation>;
+    /** `sendText` for a person's composer: in a held room the text is kept, not refused (undefined), until `sendHeldTexts`. */
+    holdText(value: unknown, operationId: string): Promise<EndpointOperation | undefined>;
+    sendHeldTexts(conversationId: string): Promise<{
+        sent: EndpointOperation[];
+        failed: {
+            operationId: string;
+            error: EndpointError;
+        }[];
+        waiting: boolean;
+    }>;
     /** A room this device holds caught up is read as it holds it: what fetches the room's new entries says so
      * (bridge.historyChanged). Otherwise a read fetches the feed first, which the polling fallback and the connected
      * stream's minute-long safety poll rely on. */

package/dist/internal/endpoint/mls-dev-text.d.ts

@@ -23,6 +23,35 @@ export declare const mlsDevOwnAnswerKey: (conversationId: string, agentId: strin
 /** Whether this device's answer to a card is committed and still on its way: queued, or its outcome uncertain, and not
  * yet applied from the feed (where the reduction takes over) nor refused. The card waits for it rather than answer twice. */
 export declare function isMlsDevOwnAnswerSending(tx: EndpointStoreTransaction, conversationId: string, agentId: string, requestId: string): Promise<boolean>;
+/**
+ * A text its sender sent while the room was held (D2, mls-rooms-by-default.md §2.7): kept here, unencrypted and never in a
+ * request, until the hold lifts. Then it is encrypted and queued as any send, in the order sent, and this record goes.
+ */
+export interface MlsDevHeldText {
+    version: 1;
+    /** The send's body as authored, its message ID fixed: what is encrypted once the room may send. */
+    body: {
+        conversationId: string;
+        messageId: string;
+        text: string;
+        replyTo?: string;
+        mentions?: string[];
+    };
+    operationId: string;
+    senderId: string;
+    senderType: 'human' | 'ai_agent';
+    createdAtMs: number;
+    /** The order sent, within the room's kept texts. */
+    sequence: number;
+    /** Refused for good when its turn came; kept so its sender sees it failed and can send it again. */
+    failed?: string;
+}
+export declare const mlsDevHeldTextPrefix: (conversationId?: string) => string;
+export declare const mlsDevHeldTextKey: (conversationId: string, messageId: string) => string;
+/** A room's held texts, oldest first. */
+export declare function readMlsDevHeldTexts(tx: EndpointStoreTransaction, conversationId: string): Promise<MlsDevHeldText[]>;
+/** Held texts per room. A send past it is refused, as a held send was before rooms kept them. */
+export declare const MLS_DEV_HELD_TEXT_MAX = 100;
 /** A deletion for everyone that reached this device, before or after the message itself (mls-payload-v3.md §4). */
 export declare const mlsDevTextDeletedKey: (conversationId: string, messageId: string) => string;
 /** The reactions Canon holds for a message's public stub, which the history shows beside its decrypted text. */
@@ -40,6 +69,9 @@ export declare function putMlsDevTextMessage(tx: EndpointStoreTransaction, value
 /** What a v3 reply quotes from this device's copy of the message it answers, trimmed to the payload's bound: a text, or
  * an item's caption or else what it is. Nothing for a card, a message deleted for everyone, or one not held here. */
 export declare function mlsDevReplyQuote(value: MlsDevLocalTextMessage | undefined, maximum: number): string | undefined;
+/** An inbox page with each last message this device holds in place of Canon's stub. The page is for this person's own
+ * screen: a row then carries a room's plaintext, so it never reaches an HTTP request or an agent's turn. */
+export declare function overlayMlsDevInboxPreviews<T>(tx: EndpointStoreTransaction, page: T): Promise<T>;
 /** `account` opens the stored sender alias to its account (mls-dev-groups.md, erasure privacy). */
 export declare function projectMlsDevTextMessage(value: MlsDevLocalTextMessage, account: MlsDevAccountResolver): Record<string, unknown>;
 /** Opens a stored principal (an alias, with the type its credential gave) to its account. */

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/internal/endpoint/transport.d.ts

@@ -58,6 +58,6 @@ export declare function createHttpEndpointTransport(options: {
     /** Names this client on every request and stream (`X-Canon-Client`), so Canon can apply its client floor. */
     client?: CanonClientIdentity;
     /** Canon refused this client as below its floor (`426 CLIENT_UPDATE_REQUIRED`), on any request or stream. Called
-     * before the error is thrown, so a host can stop wherever the refusal surfaces. */
+     * once before the error is thrown; further operations, queries, publishes and streams are blocked, not capabilities. */
     onClientUpdateRequired?(error: EndpointError): void;
 }): EndpointTransport;

package/dist/media.js

@@ -18,8 +18,10 @@ import {
   toAnthropicImageBlock,
   toAnthropicImageBlocksWithinBudget,
   uploadMediaFile
-} from "./chunks/chunk-TFSURFF6.js";
-import "./chunks/chunk-C2WJT3VX.js";
+} from "./chunks/chunk-TYZT346O.js";
+import "./chunks/chunk-YJUPKU47.js";
+import "./chunks/chunk-YHDDOADK.js";
+import "./chunks/chunk-5WPAB5MB.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 };