brass-runtime 1.13.8 → 1.15.0

package/wasm/pkg/brass_runtime_wasm_engine.js

@@ -85,6 +85,119 @@ class BrassWasmChunkBuffer {
 if (Symbol.dispose) BrassWasmChunkBuffer.prototype[Symbol.dispose] = BrassWasmChunkBuffer.prototype.free;
 exports.BrassWasmChunkBuffer = BrassWasmChunkBuffer;
 
+class BrassWasmFiberReadyQueue {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrassWasmFiberReadyQueueFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_brasswasmfiberreadyqueue_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    begin_flush() {
+        const ret = wasm.brasswasmfiberreadyqueue_begin_flush(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    clear() {
+        wasm.brasswasmfiberreadyqueue_clear(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} ran
+     * @returns {number}
+     */
+    end_flush(ran) {
+        const ret = wasm.brasswasmfiberreadyqueue_end_flush(this.__wbg_ptr, ran);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {string} tag
+     * @returns {number}
+     */
+    enqueue_fiber(fiber_id, tag) {
+        const ptr0 = passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmfiberreadyqueue_enqueue_fiber(this.__wbg_ptr, fiber_id, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {number} lane_id
+     * @returns {number}
+     */
+    enqueue_fiber_lane(fiber_id, lane_id) {
+        const ret = wasm.brasswasmfiberreadyqueue_enqueue_fiber_lane(this.__wbg_ptr, fiber_id, lane_id);
+        return ret >>> 0;
+    }
+    /**
+     * @param {string} key
+     * @returns {number}
+     */
+    intern_lane(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmfiberreadyqueue_intern_lane(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.brasswasmfiberreadyqueue_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} id
+     * @returns {number}
+     */
+    metric_u64(id) {
+        const ret = wasm.brasswasmfiberreadyqueue_metric_u64(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @param {number} flush_budget
+     * @param {number} micro_threshold
+     * @param {number} lane_capacity
+     * @param {number} lane_budget
+     * @param {number} max_lanes
+     */
+    constructor(flush_budget, micro_threshold, lane_capacity, lane_budget, max_lanes) {
+        const ret = wasm.brasswasmfiberreadyqueue_new(flush_budget, micro_threshold, lane_capacity, lane_budget, max_lanes);
+        this.__wbg_ptr = ret;
+        BrassWasmFiberReadyQueueFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {number}
+     */
+    shift_fiber() {
+        const ret = wasm.brasswasmfiberreadyqueue_shift_fiber(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    stats_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.brasswasmfiberreadyqueue_stats_json(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);
+        }
+    }
+}
+if (Symbol.dispose) BrassWasmFiberReadyQueue.prototype[Symbol.dispose] = BrassWasmFiberReadyQueue.prototype.free;
+exports.BrassWasmFiberReadyQueue = BrassWasmFiberReadyQueue;
+
 class BrassWasmFiberRegistry {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -215,6 +328,209 @@ class BrassWasmFiberRegistry {
 if (Symbol.dispose) BrassWasmFiberRegistry.prototype[Symbol.dispose] = BrassWasmFiberRegistry.prototype.free;
 exports.BrassWasmFiberRegistry = BrassWasmFiberRegistry;
 
+class BrassWasmHttpPermitPool {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrassWasmHttpPermitPoolFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_brasswasmhttppermitpool_free(ptr, 0);
+    }
+    /**
+     * @param {number} subject_id
+     * @param {number} key_id
+     * @param {bigint} now_ms
+     * @returns {number}
+     */
+    acquire(subject_id, key_id, now_ms) {
+        const ret = wasm.brasswasmhttppermitpool_acquire(this.__wbg_ptr, subject_id, key_id, now_ms);
+        return ret >>> 0;
+    }
+    /**
+     * @param {bigint} now_ms
+     * @returns {number}
+     */
+    advance_time(now_ms) {
+        const ret = wasm.brasswasmhttppermitpool_advance_time(this.__wbg_ptr, now_ms);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} permit_id
+     * @returns {boolean}
+     */
+    cancel(permit_id) {
+        const ret = wasm.brasswasmhttppermitpool_cancel(this.__wbg_ptr, permit_id);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} key
+     * @returns {number}
+     */
+    intern_key(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmhttppermitpool_intern_key(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    last_permit_id() {
+        const ret = wasm.brasswasmhttppermitpool_last_permit_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    memory() {
+        const ret = wasm.brasswasmhttppermitpool_memory(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} id
+     * @returns {number}
+     */
+    metric_u64(id) {
+        const ret = wasm.brasswasmhttppermitpool_metric_u64(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_len() {
+        const ret = wasm.brasswasmhttppermitpool_metrics_snapshot_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_ptr() {
+        const ret = wasm.brasswasmhttppermitpool_metrics_snapshot_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} concurrency
+     * @param {number} max_queue
+     * @param {bigint} queue_timeout_ms
+     */
+    constructor(concurrency, max_queue, queue_timeout_ms) {
+        const ret = wasm.brasswasmhttppermitpool_new(concurrency, max_queue, queue_timeout_ms);
+        this.__wbg_ptr = ret;
+        BrassWasmHttpPermitPoolFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {number}
+     */
+    next_deadline_ms() {
+        const ret = wasm.brasswasmhttppermitpool_next_deadline_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    permit_events_len() {
+        const ret = wasm.brasswasmhttppermitpool_permit_events_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} key_id
+     * @param {bigint} now_ms
+     * @returns {number}
+     */
+    release(key_id, now_ms) {
+        const ret = wasm.brasswasmhttppermitpool_release(this.__wbg_ptr, key_id, now_ms);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BrassWasmHttpPermitPool.prototype[Symbol.dispose] = BrassWasmHttpPermitPool.prototype.free;
+exports.BrassWasmHttpPermitPool = BrassWasmHttpPermitPool;
+
+class BrassWasmRetryPlanner {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrassWasmRetryPlannerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_brasswasmretryplanner_free(ptr, 0);
+    }
+    /**
+     * @param {number} retry_id
+     * @returns {boolean}
+     */
+    drop_state(retry_id) {
+        const ret = wasm.brasswasmretryplanner_drop_state(this.__wbg_ptr, retry_id);
+        return ret !== 0;
+    }
+    /**
+     * @returns {any}
+     */
+    memory() {
+        const ret = wasm.brasswasmretryplanner_memory(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} id
+     * @returns {number}
+     */
+    metric_u64(id) {
+        const ret = wasm.brasswasmretryplanner_metric_u64(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_len() {
+        const ret = wasm.brasswasmretryplanner_metrics_snapshot_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_ptr() {
+        const ret = wasm.brasswasmretryplanner_metrics_snapshot_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    constructor() {
+        const ret = wasm.brasswasmretryplanner_new();
+        this.__wbg_ptr = ret;
+        BrassWasmRetryPlannerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} retry_id
+     * @param {number} now_ms
+     * @param {boolean} retryable
+     * @param {number} retry_after_ms
+     * @returns {number}
+     */
+    next_delay_ms(retry_id, now_ms, retryable, retry_after_ms) {
+        const ret = wasm.brasswasmretryplanner_next_delay_ms(this.__wbg_ptr, retry_id, now_ms, retryable, retry_after_ms);
+        return ret;
+    }
+    /**
+     * @param {number} now_ms
+     * @param {number} max_retries
+     * @param {number} base_delay_ms
+     * @param {number} max_delay_ms
+     * @param {number} max_elapsed_ms
+     * @param {bigint} seed
+     * @returns {number}
+     */
+    start(now_ms, max_retries, base_delay_ms, max_delay_ms, max_elapsed_ms, seed) {
+        const ret = wasm.brasswasmretryplanner_start(this.__wbg_ptr, now_ms, max_retries, base_delay_ms, max_delay_ms, max_elapsed_ms, seed);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BrassWasmRetryPlanner.prototype[Symbol.dispose] = BrassWasmRetryPlanner.prototype.free;
+exports.BrassWasmRetryPlanner = BrassWasmRetryPlanner;
+
 class BrassWasmRingBuffer {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -291,7 +607,6 @@ class BrassWasmSchedulerStateMachine {
         wasm.__wbg_brasswasmschedulerstatemachine_free(ptr, 0);
     }
     /**
-     * Enter flushing. Returns the number of tasks this flush may run.
      * @returns {number}
      */
     begin_flush() {
@@ -309,10 +624,6 @@ class BrassWasmSchedulerStateMachine {
         wasm.brasswasmschedulerstatemachine_clear(this.__wbg_ptr);
     }
     /**
-     * Finish a flush. Returns the scheduling policy for the next flush:
-     * - 0 => schedule a micro flush
-     * - 1 => schedule a macro flush
-     * - 2 => no more work
      * @param {number} ran
      * @returns {number}
      */
@@ -321,16 +632,50 @@ class BrassWasmSchedulerStateMachine {
         return ret >>> 0;
     }
     /**
-     * Enqueue a task ref and return the scheduling policy:
-     * - 0 => schedule a micro flush
-     * - 1 => schedule a macro flush
-     * - 2 => no new flush needed
-     * - 3 => queue full / task dropped
      * @param {number} task_ref
+     * @param {string} tag
      * @returns {number}
      */
-    enqueue(task_ref) {
-        const ret = wasm.brasswasmschedulerstatemachine_enqueue(this.__wbg_ptr, task_ref);
+    enqueue(task_ref, tag) {
+        const ptr0 = passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmschedulerstatemachine_enqueue(this.__wbg_ptr, task_ref, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Enqueue multiple tasks in a single boundary crossing.
+     * Returns a Uint32Array of policies (one per task):
+     * - 0 = SCHEDULER_POLICY_MICRO
+     * - 1 = SCHEDULER_POLICY_MACRO
+     * - 2 = SCHEDULER_POLICY_NONE (already scheduled)
+     * - 3 = SCHEDULER_POLICY_DROPPED
+     * @param {Uint32Array} task_refs
+     * @param {Array<any>} tags
+     * @returns {Uint32Array}
+     */
+    enqueue_batch(task_refs, tags) {
+        const ptr0 = passArray32ToWasm0(task_refs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmschedulerstatemachine_enqueue_batch(this.__wbg_ptr, ptr0, len0, tags);
+        return ret;
+    }
+    /**
+     * @param {number} task_ref
+     * @param {number} lane_id
+     * @returns {number}
+     */
+    enqueue_lane(task_ref, lane_id) {
+        const ret = wasm.brasswasmschedulerstatemachine_enqueue_lane(this.__wbg_ptr, task_ref, lane_id);
+        return ret >>> 0;
+    }
+    /**
+     * @param {string} key
+     * @returns {number}
+     */
+    intern_lane(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmschedulerstatemachine_intern_lane(this.__wbg_ptr, ptr0, len0);
         return ret >>> 0;
     }
     /**
@@ -347,6 +692,14 @@ class BrassWasmSchedulerStateMachine {
         const ret = wasm.brasswasmschedulerstatemachine_is_scheduled(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * @param {number} lane_id
+     * @returns {number}
+     */
+    lane_len(lane_id) {
+        const ret = wasm.brasswasmschedulerstatemachine_lane_len(this.__wbg_ptr, lane_id);
+        return ret >>> 0;
+    }
     /**
      * @returns {number}
      */
@@ -355,13 +708,24 @@ class BrassWasmSchedulerStateMachine {
         return ret >>> 0;
     }
     /**
-     * @param {number} initial_capacity
+     * @param {number} id
+     * @returns {number}
+     */
+    metric_u64(id) {
+        const ret = wasm.brasswasmschedulerstatemachine_metric_u64(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @param {number} _initial_capacity
      * @param {number} max_capacity
      * @param {number} flush_budget
      * @param {number} micro_threshold
+     * @param {number} lane_capacity
+     * @param {number} lane_budget
+     * @param {number} max_lanes
      */
-    constructor(initial_capacity, max_capacity, flush_budget, micro_threshold) {
-        const ret = wasm.brasswasmschedulerstatemachine_new(initial_capacity, max_capacity, flush_budget, micro_threshold);
+    constructor(_initial_capacity, max_capacity, flush_budget, micro_threshold, lane_capacity, lane_budget, max_lanes) {
+        const ret = wasm.brasswasmschedulerstatemachine_new(_initial_capacity, max_capacity, flush_budget, micro_threshold, lane_capacity, lane_budget, max_lanes);
         this.__wbg_ptr = ret;
         BrassWasmSchedulerStateMachineFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -392,6 +756,100 @@ class BrassWasmSchedulerStateMachine {
 if (Symbol.dispose) BrassWasmSchedulerStateMachine.prototype[Symbol.dispose] = BrassWasmSchedulerStateMachine.prototype.free;
 exports.BrassWasmSchedulerStateMachine = BrassWasmSchedulerStateMachine;
 
+class BrassWasmTimerWheel {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BrassWasmTimerWheelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_brasswasmtimerwheel_free(ptr, 0);
+    }
+    /**
+     * @param {bigint} now_ms
+     * @returns {number}
+     */
+    advance_time(now_ms) {
+        const ret = wasm.brasswasmtimerwheel_advance_time(this.__wbg_ptr, now_ms);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} timer_id
+     * @returns {boolean}
+     */
+    cancel(timer_id) {
+        const ret = wasm.brasswasmtimerwheel_cancel(this.__wbg_ptr, timer_id);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    expired_len() {
+        const ret = wasm.brasswasmtimerwheel_expired_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    memory() {
+        const ret = wasm.brasswasmtimerwheel_memory(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} id
+     * @returns {number}
+     */
+    metric_u64(id) {
+        const ret = wasm.brasswasmtimerwheel_metric_u64(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_len() {
+        const ret = wasm.brasswasmtimerwheel_metrics_snapshot_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_ptr() {
+        const ret = wasm.brasswasmtimerwheel_metrics_snapshot_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {bigint} tick_ms
+     * @param {number} bucket_count
+     */
+    constructor(tick_ms, bucket_count) {
+        const ret = wasm.brasswasmtimerwheel_new(tick_ms, bucket_count);
+        this.__wbg_ptr = ret;
+        BrassWasmTimerWheelFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {number}
+     */
+    next_deadline_ms() {
+        const ret = wasm.brasswasmtimerwheel_next_deadline_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} subject_id
+     * @param {number} kind
+     * @param {bigint} deadline_ms
+     * @returns {number}
+     */
+    schedule_deadline(subject_id, kind, deadline_ms) {
+        const ret = wasm.brasswasmtimerwheel_schedule_deadline(this.__wbg_ptr, subject_id, kind, deadline_ms);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BrassWasmTimerWheel.prototype[Symbol.dispose] = BrassWasmTimerWheel.prototype.free;
+exports.BrassWasmTimerWheel = BrassWasmTimerWheel;
+
 class BrassWasmVm {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -413,12 +871,55 @@ class BrassWasmVm {
         const ret = wasm.brasswasmvm_create_fiber(this.__wbg_ptr, ptr0, len0);
         return ret >>> 0;
     }
+    /**
+     * @param {Uint32Array} program_words
+     * @returns {number}
+     */
+    create_fiber_bin(program_words) {
+        const ptr0 = passArray32ToWasm0(program_words, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmvm_create_fiber_bin(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} word_len
+     * @returns {number}
+     */
+    create_fiber_from_program_words(word_len) {
+        const ret = wasm.brasswasmvm_create_fiber_from_program_words(this.__wbg_ptr, word_len);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {number} budget
+     * @returns {Uint32Array}
+     */
+    drive_batch_bin(fiber_id, budget) {
+        const ret = wasm.brasswasmvm_drive_batch_bin(this.__wbg_ptr, fiber_id, budget);
+        return ret;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {number} budget
+     * @returns {number}
+     */
+    drive_batch_ptr(fiber_id, budget) {
+        const ret = wasm.brasswasmvm_drive_batch_ptr(this.__wbg_ptr, fiber_id, budget);
+        return ret >>> 0;
+    }
     /**
      * @param {number} fiber_id
      */
     drop_fiber(fiber_id) {
         wasm.brasswasmvm_drop_fiber(this.__wbg_ptr, fiber_id);
     }
+    /**
+     * @returns {number}
+     */
+    event_batch_len() {
+        const ret = wasm.brasswasmvm_event_batch_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * @param {number} fiber_id
      * @param {number} reason_ref
@@ -436,6 +937,55 @@ class BrassWasmVm {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {number} fiber_id
+     * @param {number} reason_ref
+     * @param {number} budget
+     * @returns {Uint32Array}
+     */
+    interrupt_bin(fiber_id, reason_ref, budget) {
+        const ret = wasm.brasswasmvm_interrupt_bin(this.__wbg_ptr, fiber_id, reason_ref, budget);
+        return ret;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {number} reason_ref
+     * @param {number} budget
+     * @returns {number}
+     */
+    interrupt_ptr(fiber_id, reason_ref, budget) {
+        const ret = wasm.brasswasmvm_interrupt_ptr(this.__wbg_ptr, fiber_id, reason_ref, budget);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {any}
+     */
+    memory() {
+        const ret = wasm.brasswasmvm_memory(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} id
+     * @returns {number}
+     */
+    metric_u64(id) {
+        const ret = wasm.brasswasmvm_metric_u64(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_len() {
+        const ret = wasm.brasswasmvm_metrics_snapshot_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    metrics_snapshot_ptr() {
+        const ret = wasm.brasswasmvm_metrics_snapshot_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     constructor() {
         const ret = wasm.brasswasmvm_new();
         this.__wbg_ptr = ret;
@@ -458,6 +1008,30 @@ class BrassWasmVm {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {number} fiber_id
+     * @returns {Uint32Array}
+     */
+    poll_bin(fiber_id) {
+        const ret = wasm.brasswasmvm_poll_bin(this.__wbg_ptr, fiber_id);
+        return ret;
+    }
+    /**
+     * @param {number} word_len
+     * @returns {number}
+     */
+    prepare_patch_words(word_len) {
+        const ret = wasm.brasswasmvm_prepare_patch_words(this.__wbg_ptr, word_len);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} word_len
+     * @returns {number}
+     */
+    prepare_program_words(word_len) {
+        const ret = wasm.brasswasmvm_prepare_program_words(this.__wbg_ptr, word_len);
+        return ret >>> 0;
+    }
     /**
      * @param {number} fiber_id
      * @param {number} root
@@ -478,6 +1052,30 @@ class BrassWasmVm {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * @param {number} fiber_id
+     * @param {number} root
+     * @param {Uint32Array} nodes_words
+     * @param {number} budget
+     * @returns {Uint32Array}
+     */
+    provide_effect_bin(fiber_id, root, nodes_words, budget) {
+        const ptr0 = passArray32ToWasm0(nodes_words, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brasswasmvm_provide_effect_bin(this.__wbg_ptr, fiber_id, root, ptr0, len0, budget);
+        return ret;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {number} root
+     * @param {number} word_len
+     * @param {number} budget
+     * @returns {number}
+     */
+    provide_effect_from_words(fiber_id, root, word_len, budget) {
+        const ret = wasm.brasswasmvm_provide_effect_from_words(this.__wbg_ptr, fiber_id, root, word_len, budget);
+        return ret >>> 0;
+    }
     /**
      * @param {number} fiber_id
      * @param {number} error_ref
@@ -495,6 +1093,26 @@ class BrassWasmVm {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {number} fiber_id
+     * @param {number} error_ref
+     * @param {number} budget
+     * @returns {Uint32Array}
+     */
+    provide_error_bin(fiber_id, error_ref, budget) {
+        const ret = wasm.brasswasmvm_provide_error_bin(this.__wbg_ptr, fiber_id, error_ref, budget);
+        return ret;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {number} error_ref
+     * @param {number} budget
+     * @returns {number}
+     */
+    provide_error_ptr(fiber_id, error_ref, budget) {
+        const ret = wasm.brasswasmvm_provide_error_ptr(this.__wbg_ptr, fiber_id, error_ref, budget);
+        return ret >>> 0;
+    }
     /**
      * @param {number} fiber_id
      * @param {number} value_ref
@@ -512,6 +1130,26 @@ class BrassWasmVm {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {number} fiber_id
+     * @param {number} value_ref
+     * @param {number} budget
+     * @returns {Uint32Array}
+     */
+    provide_value_bin(fiber_id, value_ref, budget) {
+        const ret = wasm.brasswasmvm_provide_value_bin(this.__wbg_ptr, fiber_id, value_ref, budget);
+        return ret;
+    }
+    /**
+     * @param {number} fiber_id
+     * @param {number} value_ref
+     * @param {number} budget
+     * @returns {number}
+     */
+    provide_value_ptr(fiber_id, value_ref, budget) {
+        const ret = wasm.brasswasmvm_provide_value_ptr(this.__wbg_ptr, fiber_id, value_ref, budget);
+        return ret >>> 0;
+    }
     /**
      * @returns {string}
      */
@@ -533,9 +1171,25 @@ exports.BrassWasmVm = BrassWasmVm;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_memory_c2356dd1a089dfbd: function() {
+            const ret = wasm.memory;
+            return ret;
+        },
+        __wbg___wbindgen_string_get_965592073e5d848c: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_throw_9c75d47bf9e7731e: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbg_get_652f640b3b0b6e3e: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
         __wbg_length_0a6ce016dc1460b0: function(arg0) {
             const ret = arg0.length;
             return ret;
@@ -544,9 +1198,16 @@ function __wbg_get_imports() {
             const ret = new Array(arg0 >>> 0);
             return ret;
         },
+        __wbg_new_with_length_b91f070a091394cc: function(arg0) {
+            const ret = new Uint32Array(arg0 >>> 0);
+            return ret;
+        },
         __wbg_set_f614f6a0608d1d1d: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
+        __wbg_set_index_9fd290d1cce481b3: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2 >>> 0;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -566,23 +1227,51 @@ function __wbg_get_imports() {
 const BrassWasmChunkBufferFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmchunkbuffer_free(ptr, 1));
+const BrassWasmFiberReadyQueueFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmfiberreadyqueue_free(ptr, 1));
 const BrassWasmFiberRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmfiberregistry_free(ptr, 1));
+const BrassWasmHttpPermitPoolFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmhttppermitpool_free(ptr, 1));
+const BrassWasmRetryPlannerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmretryplanner_free(ptr, 1));
 const BrassWasmRingBufferFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmringbuffer_free(ptr, 1));
 const BrassWasmSchedulerStateMachineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmschedulerstatemachine_free(ptr, 1));
+const BrassWasmTimerWheelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmtimerwheel_free(ptr, 1));
 const BrassWasmVmFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_brasswasmvm_free(ptr, 1));
 
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -591,6 +1280,17 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);