runmat 0.6.1 → 0.6.2-dev.0

package/dist/pkg-web/runmat_wasm_web.js

@@ -1,5 +1,390 @@
 /* @ts-self-types="./runmat_wasm_web.d.ts" */
 
+/**
+ * Rust-owned application encryption/replay state for a browser WebSocket or
+ * WebTransport host. JavaScript transports the returned opaque bytes without
+ * receiving the run key or implementing protocol crypto.
+ */
+export class BrowserEncryptedFrameSession {
+    static __wrap(ptr) {
+        const obj = Object.create(BrowserEncryptedFrameSession.prototype);
+        obj.__wbg_ptr = ptr;
+        BrowserEncryptedFrameSessionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrowserEncryptedFrameSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_browserencryptedframesession_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} encoded
+     * @returns {Uint8Array}
+     */
+    open(encoded) {
+        const ptr0 = passArray8ToWasm0(encoded, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserencryptedframesession_open(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    /**
+     * @param {number} frame_kind
+     * @param {Uint8Array} plaintext
+     * @returns {Uint8Array}
+     */
+    seal(frame_kind, plaintext) {
+        const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserencryptedframesession_seal(this.__wbg_ptr, frame_kind, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+}
+if (Symbol.dispose) BrowserEncryptedFrameSession.prototype[Symbol.dispose] = BrowserEncryptedFrameSession.prototype.free;
+
+export class BrowserExecutionRecipient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrowserExecutionRecipientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_browserexecutionrecipient_free(ptr, 0);
+    }
+    /**
+     * @param {string} fingerprint
+     * @param {bigint} valid_after_unix_millis
+     * @param {bigint} valid_before_unix_millis
+     */
+    constructor(fingerprint, valid_after_unix_millis, valid_before_unix_millis) {
+        const ptr0 = passStringToWasm0(fingerprint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserexecutionrecipient_new(ptr0, len0, valid_after_unix_millis, valid_before_unix_millis);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        BrowserExecutionRecipientFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} artifact
+     * @returns {Uint8Array}
+     */
+    open(artifact) {
+        const ret = wasm.browserexecutionrecipient_open(this.__wbg_ptr, artifact);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {any} envelope
+     * @param {string} expected_run_identity
+     * @param {number} expected_key_epoch
+     * @returns {BrowserRunKey}
+     */
+    openRunKey(envelope, expected_run_identity, expected_key_epoch) {
+        const ptr0 = passStringToWasm0(expected_run_identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserexecutionrecipient_openRunKey(this.__wbg_ptr, envelope, ptr0, len0, expected_key_epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BrowserRunKey.__wrap(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get recipient() {
+        const ret = wasm.browserexecutionrecipient_recipient(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} context
+     * @param {Uint8Array} plaintext
+     * @returns {any}
+     */
+    seal(context, plaintext) {
+        const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserexecutionrecipient_seal(this.__wbg_ptr, context, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) BrowserExecutionRecipient.prototype[Symbol.dispose] = BrowserExecutionRecipient.prototype.free;
+
+/**
+ * Browser-side authority for the content-blind two-stage submission.
+ *
+ * Network requests remain a small TypeScript host responsibility. Rust owns
+ * the run key, exact endpoint recipient, encryption contexts, and canonical
+ * ciphertext bytes so browser and native submissions cannot drift.
+ */
+export class BrowserRemoteSubmission {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrowserRemoteSubmissionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_browserremotesubmission_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} session_id
+     * @param {string} direction
+     * @param {number} key_epoch
+     * @returns {BrowserEncryptedFrameSession}
+     */
+    createFrameSession(session_id, direction, key_epoch) {
+        const ptr0 = passArray8ToWasm0(session_id, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(direction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.browserremotesubmission_createFrameSession(this.__wbg_ptr, ptr0, len0, ptr1, len1, key_epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BrowserEncryptedFrameSession.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} purpose
+     * @param {Uint8Array} ciphertext
+     * @returns {Uint8Array}
+     */
+    decryptObject(purpose, ciphertext) {
+        const ptr0 = passStringToWasm0(purpose, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.browserremotesubmission_decryptObject(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+    }
+    /**
+     * @returns {any}
+     */
+    get directQuicEndpoints() {
+        const ret = wasm.browserremotesubmission_directQuicEndpoints(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} purpose
+     * @param {Uint8Array} plaintext
+     * @param {string | null | undefined} task_identity
+     * @param {string | null | undefined} attempt_identity
+     * @param {bigint} chunk_index
+     * @param {number} key_epoch
+     * @returns {Uint8Array}
+     */
+    encryptObject(purpose, plaintext, task_identity, attempt_identity, chunk_index, key_epoch) {
+        const ptr0 = passStringToWasm0(purpose, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(task_identity) ? 0 : passStringToWasm0(task_identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(attempt_identity) ? 0 : passStringToWasm0(attempt_identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.browserremotesubmission_encryptObject(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, chunk_index, key_epoch);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v5;
+    }
+    /**
+     * @returns {string}
+     */
+    get endpointFingerprint() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.browserremotesubmission_endpointFingerprint(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} run_identity
+     * @param {any} verified_endpoint
+     */
+    constructor(run_identity, verified_endpoint) {
+        const ptr0 = passStringToWasm0(run_identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserremotesubmission_new(ptr0, len0, verified_endpoint);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        BrowserRemoteSubmissionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} key_epoch
+     * @returns {Uint8Array}
+     */
+    sealRunKeyEnvelope(key_epoch) {
+        const ret = wasm.browserremotesubmission_sealRunKeyEnvelope(this.__wbg_ptr, key_epoch);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Seal this submission's content key to an organization recovery
+     * recipient returned by the public Server policy API.
+     * @param {any} recipient
+     * @param {number} key_epoch
+     * @returns {Uint8Array}
+     */
+    sealRunKeyForRecipient(recipient, key_epoch) {
+        const ret = wasm.browserremotesubmission_sealRunKeyForRecipient(this.__wbg_ptr, recipient, key_epoch);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) BrowserRemoteSubmission.prototype[Symbol.dispose] = BrowserRemoteSubmission.prototype.free;
+
+/**
+ * Browser-owned content key for one remote run. JavaScript can use it to
+ * encrypt/decrypt objects and create recipient envelopes, but cannot extract
+ * the raw key bytes.
+ */
+export class BrowserRunKey {
+    static __wrap(ptr) {
+        const obj = Object.create(BrowserRunKey.prototype);
+        obj.__wbg_ptr = ptr;
+        BrowserRunKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrowserRunKeyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_browserrunkey_free(ptr, 0);
+    }
+    /**
+     * @param {string} run_identity
+     * @param {Uint8Array} session_id
+     * @param {string} direction
+     * @param {number} key_epoch
+     * @returns {BrowserEncryptedFrameSession}
+     */
+    createFrameSession(run_identity, session_id, direction, key_epoch) {
+        const ptr0 = passStringToWasm0(run_identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(session_id, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(direction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.browserrunkey_createFrameSession(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, key_epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BrowserEncryptedFrameSession.__wrap(ret[0]);
+    }
+    constructor() {
+        const ret = wasm.browserrunkey_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        BrowserRunKeyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} object
+     * @returns {Uint8Array}
+     */
+    open(object) {
+        const ret = wasm.browserrunkey_open(this.__wbg_ptr, object);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {any} context
+     * @param {Uint8Array} plaintext
+     * @returns {any}
+     */
+    seal(context, plaintext) {
+        const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserrunkey_seal(this.__wbg_ptr, context, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} recipient
+     * @param {string} run_identity
+     * @param {number} key_epoch
+     * @returns {any}
+     */
+    sealForRecipient(recipient, run_identity, key_epoch) {
+        const ptr0 = passStringToWasm0(run_identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.browserrunkey_sealForRecipient(this.__wbg_ptr, recipient, ptr0, len0, key_epoch);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) BrowserRunKey.prototype[Symbol.dispose] = BrowserRunKey.prototype.free;
+
 export class RunMatWasm {
     static __wrap(ptr) {
         const obj = Object.create(RunMatWasm.prototype);
@@ -50,9 +435,29 @@ export class RunMatWasm {
         const ret = wasm.runmatwasm_checkFeaStudy(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    clearProjectHandoff() {
+        const ret = wasm.runmatwasm_clearProjectHandoff(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     clearWorkspace() {
         wasm.runmatwasm_clearWorkspace(this.__wbg_ptr);
     }
+    /**
+     * Return semantic discovery for the exact caller-frozen run snapshot.
+     * The Core session verifies it against the installed project handoff
+     * before static analysis; no browser filesystem rediscovery occurs.
+     * @param {any} value
+     * @returns {any}
+     */
+    discoverTests(value) {
+        const ret = wasm.runmatwasm_discoverTests(this.__wbg_ptr, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     dispose() {
         wasm.runmatwasm_dispose(this.__wbg_ptr);
     }
@@ -74,6 +479,17 @@ export class RunMatWasm {
         const ret = wasm.runmatwasm_executeRequest(this.__wbg_ptr, request_value);
         return ret;
     }
+    /**
+     * Execute one exact planned test in this session. Browser worker adapters
+     * use this narrow endpoint; scheduling remains in the portable Rust
+     * coordinator.
+     * @param {any} input
+     * @returns {Promise<any>}
+     */
+    executeTestAttempt(input) {
+        const ret = wasm.runmatwasm_executeTestAttempt(this.__wbg_ptr, input);
+        return ret;
+    }
     /**
      * @param {number} handle
      * @param {number | null} [scene_budget_bytes]
@@ -215,6 +631,17 @@ export class RunMatWasm {
         const ret = wasm.runmatwasm_inspectDataFile(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * @param {any} value
+     * @returns {any}
+     */
+    installProjectHandoff(value) {
+        const ret = wasm.runmatwasm_installProjectHandoff(this.__wbg_ptr, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {string} path
      * @param {string} array
@@ -248,6 +675,27 @@ export class RunMatWasm {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @returns {Promise<any>}
+     */
+    packageCacheSnapshot() {
+        const ret = wasm.runmatwasm_packageCacheSnapshot(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Discover and construct the selected immutable plan through the same
+     * Core authority used by native hosts.
+     * @param {any} snapshot
+     * @param {any} selector
+     * @returns {any}
+     */
+    prepareTests(snapshot, selector) {
+        const ret = wasm.runmatwasm_prepareTests(this.__wbg_ptr, snapshot, selector);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {string} path
      * @param {any} budget_value
@@ -259,6 +707,16 @@ export class RunMatWasm {
         const ret = wasm.runmatwasm_previewGeometry(this.__wbg_ptr, ptr0, len0, budget_value);
         return ret;
     }
+    /**
+     * @returns {any}
+     */
+    projectRevision() {
+        const ret = wasm.runmatwasm_projectRevision(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     resetSession() {
         const ret = wasm.runmatwasm_resetSession(this.__wbg_ptr);
         if (ret[1]) {
@@ -363,6 +821,37 @@ export function bindSurfaceToFigure(surface_id, handle) {
     }
 }
 
+/**
+ * @param {any} project_handoff
+ * @param {any} recipe
+ * @param {Uint8Array} executable_bytes
+ * @returns {Promise<Uint8Array>}
+ */
+export function buildExecutionBundle(project_handoff, recipe, executable_bytes) {
+    const ptr0 = passArray8ToWasm0(executable_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.buildExecutionBundle(project_handoff, recipe, ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {string} repository
+ * @param {string} subdir
+ * @param {any} value
+ * @returns {any}
+ */
+export function buildGitSnapshot(repository, subdir, value) {
+    const ptr0 = passStringToWasm0(repository, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(subdir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.buildGitSnapshot(ptr0, len0, ptr1, len1, value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {any} handle
  * @returns {number}
@@ -424,6 +913,20 @@ export function currentFigureHandle() {
     return ret >>> 0;
 }
 
+/**
+ * @param {string} input
+ * @returns {any}
+ */
+export function decodePackageLock(input) {
+    const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decodePackageLock(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {number} surface_id
  */
@@ -431,6 +934,54 @@ export function destroyPlotSurface(surface_id) {
     wasm.destroyPlotSurface(surface_id);
 }
 
+/**
+ * @param {any} value
+ * @returns {string}
+ */
+export function encodePackageLock(value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.encodePackageLock(value);
+        var ptr1 = ret[0];
+        var len1 = ret[1];
+        if (ret[3]) {
+            ptr1 = 0; len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {any} request
+ * @returns {Promise<any>}
+ */
+export function executeProgramArtifact(request) {
+    const ret = wasm.executeProgramArtifact(request);
+    return ret;
+}
+
+/**
+ * Build the exact browser WebSocket subprotocol list for an authenticated
+ * relay capability returned by the admission endpoint.
+ * @param {string} ticket
+ * @returns {any}
+ */
+export function executionRelayProtocols(ticket) {
+    const ptr0 = passStringToWasm0(ticket, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.executionRelayProtocols(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {number} surface_id
  */
@@ -441,6 +992,18 @@ export function fitPlotSurfaceExtents(surface_id) {
     }
 }
 
+/**
+ * @param {any} value
+ * @returns {any}
+ */
+export function freezeTestSnapshot(value) {
+    const ret = wasm.freezeTestSnapshot(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {number} surface_id
  * @returns {any}
@@ -464,6 +1027,18 @@ export function handlePlotSurfaceEvent(surface_id, event) {
     }
 }
 
+/**
+ * @param {any} value
+ * @returns {any}
+ */
+export function handoffFromFrozenProject(value) {
+    const ret = wasm.handoffFromFrozenProject(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {any} options
  * @returns {Promise<RunMatWasm>}
@@ -473,6 +1048,58 @@ export function initRunMat(options) {
     return ret;
 }
 
+/**
+ * Verify and materialize an exact execution bundle into the active browser
+ * filesystem provider, returning the existing frozen-project handoff rebased
+ * to those bytes. Browser worker hosts should use an ephemeral provider and
+ * dispose it with the worker.
+ * @param {Uint8Array} archive
+ * @returns {Promise<any>}
+ */
+export function materializeExecutionBundle(archive) {
+    const ptr0 = passArray8ToWasm0(archive, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.materializeExecutionBundle(ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {string} source
+ * @param {string} format
+ * @returns {any}
+ */
+export function migrateLegacyRunmatConfig(source, format) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.migrateLegacyRunmatConfig(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} legacy_source
+ * @param {string} destination_source
+ * @param {string} format
+ * @returns {any}
+ */
+export function migrateLegacyRunmatConfigInto(legacy_source, destination_source, format) {
+    const ptr0 = passStringToWasm0(legacy_source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(destination_source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.migrateLegacyRunmatConfigInto(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @returns {number}
  */
@@ -491,6 +1118,86 @@ export function onFigureEvent(callback) {
     }
 }
 
+/**
+ * @param {any} provider
+ * @param {any} request
+ * @returns {Promise<any>}
+ */
+export function packageCacheAcquireLease(provider, request) {
+    const ret = wasm.packageCacheAcquireLease(provider, request);
+    return ret;
+}
+
+/**
+ * @param {any} provider
+ * @param {bigint} target_bytes
+ * @param {bigint} retain_recent_ms
+ * @returns {Promise<any>}
+ */
+export function packageCacheGc(provider, target_bytes, retain_recent_ms) {
+    const ret = wasm.packageCacheGc(provider, target_bytes, retain_recent_ms);
+    return ret;
+}
+
+/**
+ * @param {any} provider
+ * @param {any} value
+ * @returns {Promise<void>}
+ */
+export function packageCacheReleaseLease(provider, value) {
+    const ret = wasm.packageCacheReleaseLease(provider, value);
+    return ret;
+}
+
+/**
+ * @param {any} provider
+ * @param {any} value
+ * @param {bigint} ttl_ms
+ * @returns {Promise<any>}
+ */
+export function packageCacheRenewLease(provider, value, ttl_ms) {
+    const ret = wasm.packageCacheRenewLease(provider, value, ttl_ms);
+    return ret;
+}
+
+/**
+ * @param {any} provider
+ * @returns {Promise<any>}
+ */
+export function packageCacheStatus(provider) {
+    const ret = wasm.packageCacheStatus(provider);
+    return ret;
+}
+
+/**
+ * @param {string} source
+ * @param {string} format
+ * @param {any} patch
+ * @returns {string}
+ */
+export function patchRunmatConfig(source, format, patch) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.patchRunmatConfig(ptr0, len0, ptr1, len1, patch);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * @param {number} surface_id
  * @param {number} x
@@ -505,6 +1212,18 @@ export function pickGeometrySceneRegion(surface_id, x, y) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {any} value
+ * @returns {any}
+ */
+export function planGitAcquisition(value) {
+    const ret = wasm.planGitAcquisition(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @returns {boolean}
  */
@@ -545,6 +1264,40 @@ export function presentSurface(surface_id) {
     }
 }
 
+/**
+ * @param {string} source_path
+ * @returns {Promise<any>}
+ */
+export function projectHandoff(source_path) {
+    const ptr0 = passStringToWasm0(source_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.projectHandoff(ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {string} source_path
+ * @returns {Promise<any>}
+ */
+export function projectRevision(source_path) {
+    const ptr0 = passStringToWasm0(source_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.projectRevision(ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {any} value
+ * @returns {any}
+ */
+export function projectTestLayout(value) {
+    const ret = wasm.projectTestLayout(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {number} handle
  */
@@ -639,6 +1392,61 @@ export function resizePlotSurface(surface_id, width, height, pixels_per_point) {
     }
 }
 
+/**
+ * @param {any} request
+ * @param {any} provider
+ * @param {any} filesystem
+ * @returns {Promise<any>}
+ */
+export function resolveProject(request, provider, filesystem) {
+    const ret = wasm.resolveProject(request, provider, filesystem);
+    return ret;
+}
+
+/**
+ * @param {string} source
+ * @param {string} format
+ * @returns {any}
+ */
+export function resolveRunmatConfig(source, format) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.resolveRunmatConfig(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Run a complete immutable test plan through the portable Rust coordinator.
+ * JavaScript owns only worker construction, transport, termination, and host
+ * storage; it does not implement scheduling or lifecycle policy.
+ * @param {any} input
+ * @param {any} backend
+ * @returns {Promise<any>}
+ */
+export function runTests(input, backend) {
+    const ret = wasm.runTests(input, backend);
+    return ret;
+}
+
+/**
+ * Run tests and project each canonical coordinator event to JavaScript as it
+ * occurs. The callback is a projection only; scheduling, lifecycle, results,
+ * and report construction remain owned by the portable coordinator.
+ * @param {any} input
+ * @param {any} backend
+ * @param {any} observer
+ * @returns {Promise<any>}
+ */
+export function runTestsWithEvents(input, backend, observer) {
+    const ret = wasm.runTestsWithEvents(input, backend, observer);
+    return ret;
+}
+
 /**
  * @param {number} handle
  */
@@ -770,6 +1578,45 @@ export function unsubscribeStdout(id) {
 export function unsubscribeTraceEvents(id) {
     wasm.unsubscribeTraceEvents(id);
 }
+
+/**
+ * @param {any} value
+ * @returns {any}
+ */
+export function validateGitSnapshot(value) {
+    const ret = wasm.validateGitSnapshot(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} value
+ * @returns {any}
+ */
+export function validateProjectHandoff(value) {
+    const ret = wasm.validateProjectHandoff(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Verify signed Server admission evidence under browser-local trust policy and
+ * return the exact HPKE recipient accepted for the run.
+ * @param {any} evidence
+ * @param {any} policy
+ * @returns {any}
+ */
+export function verifyExecutionEndpointIdentity(evidence, policy) {
+    const ret = wasm.verifyExecutionEndpointIdentity(evidence, policy);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -882,6 +1729,10 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_33c39e13d73b25f6: function(arg0) {
             arg0._wbg_cb_unref();
         },
+        __wbg_apply_b37ddce350829e95: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.apply(arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_beginComputePass_097033d61ef8af0f: function(arg0, arg1) {
             const ret = arg0.beginComputePass(arg1);
             return ret;
@@ -1038,6 +1889,10 @@ function __wbg_get_imports() {
             const ret = arg0.features;
             return ret;
         },
+        __wbg_fill_36d0880093490529: function(arg0, arg1, arg2, arg3) {
+            const ret = arg0.fill(arg1, arg2 >>> 0, arg3 >>> 0);
+            return ret;
+        },
         __wbg_finish_2440fb64e53f7d5a: function(arg0, arg1) {
             const ret = arg0.finish(arg1);
             return ret;
@@ -1081,6 +1936,10 @@ function __wbg_get_imports() {
             const ret = arg0.getPreferredCanvasFormat();
             return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 96) - 1;
         },
+        __wbg_getRandomValues_099a00034ea06d0c: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.getRandomValues(getArrayU8FromWasm0(arg1, arg2));
+            return ret;
+        }, arguments); },
         __wbg_getRandomValues_a697888e9ba1eee3: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
@@ -1157,6 +2016,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Crypto_cecf3f85e92e02f6: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Crypto;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_DomException_7e2ce66bfb012d37: function(arg0) {
             let result;
             try {
@@ -2423,23 +3292,23 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, arg2, arg3, arg4);
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 11348, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hb871e9c5faa9fe3a);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 12756, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h6e5155eec27884fe);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 11372, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 13388, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h0fd58337c3bb7841);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 3306, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hc1df989025b3e68f);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 3910, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hfc24b3905a218ecf);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUUncapturedErrorEvent")], shim_idx: 11348, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hb871e9c5faa9fe3a_3);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUUncapturedErrorEvent")], shim_idx: 12756, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h6e5155eec27884fe_3);
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0) {
@@ -2490,16 +3359,16 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__hb871e9c5faa9fe3a(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hb871e9c5faa9fe3a(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h6e5155eec27884fe(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h6e5155eec27884fe(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hc1df989025b3e68f(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hc1df989025b3e68f(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__hfc24b3905a218ecf(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hfc24b3905a218ecf(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hb871e9c5faa9fe3a_3(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hb871e9c5faa9fe3a_3(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h6e5155eec27884fe_3(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h6e5155eec27884fe_3(arg0, arg1, arg2);
 }
 
 function wasm_bindgen__convert__closures_____invoke__h0fd58337c3bb7841(arg0, arg1, arg2) {
@@ -2593,6 +3462,18 @@ const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versioncha
 
 
 const __wbindgen_enum_XmlHttpRequestResponseType = ["", "arraybuffer", "blob", "document", "json", "text"];
+const BrowserEncryptedFrameSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_browserencryptedframesession_free(ptr, 1));
+const BrowserExecutionRecipientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_browserexecutionrecipient_free(ptr, 1));
+const BrowserRemoteSubmissionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_browserremotesubmission_free(ptr, 1));
+const BrowserRunKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_browserrunkey_free(ptr, 1));
 const RunMatWasmFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_runmatwasm_free(ptr, 1));