@polyengine/runtime 0.1.0-pre.g633468a

package/types/intrinsics/async_builtins.d.ts

@@ -0,0 +1,69 @@
+import type { SuspensionMode } from "../jspi/mod.js";
+import type { ValType } from "../cabi/types.js";
+import type { ComponentInstanceState } from "../task/mod.js";
+import type { CoreFn, ResolvedOptions } from "../exec/boundary.js";
+/** Services these built-ins need from the executor. */
+export interface AsyncTrampolineContext {
+    componentInstance(index: number): ComponentInstanceState;
+    /** Resolved canonical options by `canonicalOptions` index. */
+    options(index: number): ResolvedOptions;
+    /** The element types of an interned results *tuple* (`task-return`). */
+    resultTypes(index: number): ValType[];
+}
+/**
+ * `BLOCKED` sentinel of `canon_subtask_cancel` (definitions.py line 2467).
+ */
+export declare const BLOCKED = 4294967295;
+/** definitions.py `canon_task_return` (line 2384). */
+export declare function createTaskReturn(decl: {
+    results: number;
+    resultType: number | null;
+    options: number;
+}, ctx: AsyncTrampolineContext): CoreFn;
+/** definitions.py `canon_task_cancel` (line 2397). */
+export declare function createTaskCancel(): CoreFn;
+/** definitions.py `canon_backpressure_inc` (line 2368). */
+export declare function createBackpressureInc(inst: ComponentInstanceState): CoreFn;
+/** definitions.py `canon_backpressure_dec` (line 2375). */
+export declare function createBackpressureDec(inst: ComponentInstanceState): CoreFn;
+/** definitions.py `canon_waitable_set_new` (line 2406). */
+export declare function createWaitableSetNew(inst: ComponentInstanceState): CoreFn;
+/**
+ * definitions.py `canon_waitable_set_wait` (line 2414).
+ *
+ * The reference blocks the calling thread until the set has an event. From a
+ * stackless (callback-ABI) guest there is no wasm stack to suspend, so this
+ * only succeeds when an event is *already* pending — which is the reference's
+ * own non-blocking branch of `Thread.wait_until`. Otherwise: `needsJspi`.
+ *
+ * A guest using the callback ABI is expected to return the `WAIT` callback
+ * code rather than call this built-in; hitting the JSPI path here means the
+ * component uses the stackful async ABI.
+ */
+export declare function createWaitableSetWait(decl: {
+    options: number;
+}, ctx: AsyncTrampolineContext, inst: ComponentInstanceState, mode?: SuspensionMode): CoreFn;
+/** definitions.py `canon_waitable_set_poll` (line 2431). */
+export declare function createWaitableSetPoll(decl: {
+    options: number;
+}, ctx: AsyncTrampolineContext, inst: ComponentInstanceState): CoreFn;
+/** definitions.py `canon_waitable_set_drop` (line 2441). */
+export declare function createWaitableSetDrop(inst: ComponentInstanceState): CoreFn;
+/** definitions.py `canon_waitable_join` (line 2451). */
+export declare function createWaitableJoin(inst: ComponentInstanceState): CoreFn;
+/** definitions.py `canon_subtask_drop` (line 2494). */
+export declare function createSubtaskDrop(inst: ComponentInstanceState): CoreFn;
+export declare function createSubtaskCancel(decl: {
+    async?: boolean;
+}, inst: ComponentInstanceState, mode?: SuspensionMode): CoreFn;
+/**
+ * definitions.py `canon_thread_yield` (line 2728).
+ *
+ * Yielding blocks the calling wasm frame until the scheduler comes back to
+ * it. A callback-ABI guest expresses the same intent by returning the `YIELD`
+ * callback code, which this runtime implements fully (exec/boundary.ts); the
+ * *built-in* form needs a suspendable stack.
+ */
+export declare function createThreadYield(decl: {
+    cancellable?: boolean;
+}, mode?: SuspensionMode): CoreFn;

package/types/intrinsics/context.d.ts

@@ -0,0 +1,28 @@
+import type { CoreFn } from "../exec/boundary.js";
+/**
+ * Number of `i32` context slots per thread. definitions.py `Thread.storage`
+ * is initialised `[0,0]` (line 347) and `canon_context_{get,set}` assert
+ * `i < len(thread.storage)` — so exactly two, matching the intrinsic names
+ * `context-*-i32-0` and `context-*-i32-1`.
+ */
+export declare const NUM_CONTEXT_SLOTS = 2;
+/**
+ * definitions.py `canon_context_get` (line 2348).
+ *
+ * The storage is **per thread**, not per task: two threads of one task have
+ * independent context. wit-bindgen 0.60 keeps its async-executor task pointer
+ * in slot 0, which is why this intrinsic is the entry blocker for async
+ * guests.
+ */
+export declare function canonContextGet(i: number): number;
+export declare function ctxThreadId(t: unknown): string;
+/** definitions.py `canon_context_set` (line 2358). */
+export declare function canonContextSet(i: number, v: number): void;
+/**
+ * Materialize one `unsafe-intrinsic` CoreDef as a core function.
+ *
+ * Called during initializer resolution — i.e. at instantiate time — so an
+ * unimplementable symbol fails instantiation rather than the first call
+ * (contracts/plan-format.md "Executor obligations").
+ */
+export declare function createUnsafeIntrinsic(symbol: string): CoreFn;

package/types/intrinsics/errors.d.ts

@@ -0,0 +1,5 @@
+/** Instantiate-time failure for functionality scheduled after M0. */
+export declare class UnsupportedFeatureError extends Error {
+    milestone: "M1" | "M2" | "M2-streams" | "M2-jspi";
+    constructor(milestone: "M1" | "M2" | "M2-streams" | "M2-jspi", what: string);
+}

package/types/intrinsics/fact_calls.d.ts

@@ -0,0 +1,120 @@
+import type { CoreValue, ValType } from "../cabi/types.js";
+import { ComponentInstanceState } from "../task/mod.js";
+import { type CoreFn, type ExecutionStats } from "../exec/boundary.js";
+/** `START_FLAG_ASYNC_CALLEE` (`component.rs:52`). */
+export declare const START_FLAG_ASYNC_CALLEE = 1;
+/** The state `prepare-call` stashes for the following `*-start-call`. */
+export interface PreparedCall {
+    /** `[async-start]` adapter export — the reference's `on_start`. */
+    start: CoreFn;
+    /** `[async-return]` adapter export — the reference's `on_resolve`. */
+    return_: CoreFn;
+    callerInst: ComponentInstanceState;
+    calleeInst: ComponentInstanceState;
+    /** `TypeTupleIndex` of the callee's (lifted) results. */
+    taskReturnType: number;
+    /** Whether the callee's *function type* is async. */
+    calleeAsync: boolean;
+    stringEncoding: number;
+    resultCountOrMax: number;
+    /** The caller's own flat arguments, as forwarded to `prepare-call`. */
+    params: CoreValue[];
+    /**
+     * Where the *caller's* results go, decoded from
+     * `result_count_or_max_if_async` exactly as wasmtime's `ResultInfo`
+     * (`concurrent.rs:2815-2836`):
+     *
+     *   * async caller **with** a result -> `Heap`, retptr = last param
+     *   * async caller without a result  -> `Stack`
+     *   * sync caller whose results spill (`result_count > MAX_FLAT_RESULTS`)
+     *                                    -> `Heap`, retptr = last param
+     *   * sync caller otherwise          -> `Stack`
+     *
+     * In the `Heap` case the retptr must be **appended** to the
+     * `[async-return]` arguments (`concurrent.rs:2916-2919`) — it is the last
+     * parameter of `async_return_signature` (fact/signature.rs:166,178), not
+     * something the callee produced.
+     */
+    resultInfo: {
+        kind: "heap";
+        retptr: CoreValue;
+    } | {
+        kind: "stack";
+    };
+    /** True when the caller used the async ABI *and* has a result. */
+    asyncCallerWithResult: boolean;
+    /**
+     * The memory `prepare-call` names (`component/info.rs:1059`: "the memory
+     * used to verify that the memory specified for the `task.return` that is
+     * called at runtime matches the one specified in the lifted export").
+     *
+     * Decoded faithfully, but NOT usable for that verification: it is the
+     * *adapter's* view (`adapter.lift.options...memory`) and is `None` for
+     * callees whose own `task.return` options do name a memory. wasmtime gets
+     * away with the check because it holds the lift memory first-hand and its
+     * comparison is one-sided (concurrent.rs:3344-3358). Kept because it is the
+     * wire field and the task's options are structurally built from it; see the
+     * comment on the memory half of the check in async_builtins.ts.
+     */
+    memory: unknown | null;
+}
+/** Executor services these intrinsics need. */
+export interface FactCallContext {
+    componentInstance(index: number): ComponentInstanceState;
+    /** Element types of an interned results tuple (a `plan.types` index). */
+    resultTypes(index: number): ValType[];
+    /**
+     * Element types for a *raw* wasmtime `TypeTupleIndex` (what `prepare-call`
+     * passes as `task_return_type`), or `null` if the plan maps none — plan v3,
+     * see `LoadedPlan.resultTupleTypes`.
+     */
+    resultTypesForTuple(tupleIndex: number): ValType[] | null;
+    /** `RuntimeCallbackIndex` -> the callee's callback core function. */
+    callback(index: number): CoreFn;
+    /** `RuntimeMemoryIndex` -> the memory `task.return` must match, if any. */
+    memoryToken(index: number): unknown;
+    stats: ExecutionStats;
+    /** Suspension discipline (jspi/bridge.ts). */
+    suspensionMode: import("../jspi/mod.js").SuspensionMode;
+    /**
+     * Can this specific callee's code reach a suspension point? Computed per
+     * core instance at instantiation (see `Executor.suspendableFuncs`). Decides
+     * whether the callee gets its own `promising` entry.
+     */
+    calleeCanBlock?(fn: unknown): boolean;
+    /**
+     * The single in-flight prepared call. wasmtime keeps this per *task*; a
+     * single slot is equivalent here because `prepare-call` and its
+     * `*-start-call` are emitted back-to-back in one adapter body
+     * (`trampoline.rs:486-508`) with no suspension point between them, so two
+     * preparations can never be outstanding at once. Asserted, not assumed.
+     */
+    prepared: {
+        current: PreparedCall | null;
+    };
+    /** See `TrampolineContext.factStartScopes` (intrinsics/mod.ts). */
+    factStartScopes: import("./mod.js").FactStartScope[];
+}
+export declare function createPrepareCall(decl: {
+    memory: number | null;
+}, ctx: FactCallContext): CoreFn;
+/**
+ * A sync-lowered import calling an async-lifted export
+ * (`compile_sync_to_async_adapter`, trampoline.rs:607). The caller's wasm frame
+ * is blocked for the duration, so this must produce the results *now*.
+ */
+export declare function createSyncStartCall(decl: {
+    callback: number | null;
+}, ctx: FactCallContext): CoreFn;
+/**
+ * An async-lowered import calling any export (`compile_async_to_async_adapter`
+ * / `compile_async_to_sync_adapter`). Returns the packed subtask status the
+ * guest already knows how to interpret — the same
+ * `state | (subtaski << 4)` encoding `canon_lower` produces
+ * (definitions.py line 2308), so the caller's callback loop and waitable sets
+ * work unchanged.
+ */
+export declare function createAsyncStartCall(decl: {
+    callback: number | null;
+    postReturn: number | null;
+}, ctx: FactCallContext): CoreFn;

package/types/intrinsics/mod.d.ts

@@ -0,0 +1,187 @@
+import { ResourceHandle } from "../cabi/handles.js";
+import type { ResourceTypeInfo } from "../cabi/types.js";
+import type { ComponentInstanceState } from "../task/mod.js";
+import type { WireTrampoline } from "../plan/format.js";
+import type { CoreFn, ExecutionStats } from "../exec/boundary.js";
+import { type PreparedCall } from "./fact_calls.js";
+import { type TranscodeMemory } from "./transcode.js";
+export * from "./transcode.js";
+export * from "./context.js";
+export * from "./async_builtins.js";
+export * from "./fact_calls.js";
+export * from "./stream_builtins.js";
+/**
+ * Where a host trap thrown *inside* a FACT adapter is remembered.
+ *
+ * FACT wraps every adapter body in a `try_table … catch_all` exception
+ * barrier (wasmtime-environ 47.0.3 `fact/trampoline.rs:3939`
+ * `enter_exception_barrier`) so that a guest exception escaping a component
+ * becomes a trap rather than unwinding into the caller. In wasmtime a host
+ * trap unwinds out of band and is unaffected; in a JS host our traps *are*
+ * JS exceptions, so the barrier swallows them and re-raises the generic
+ * `UncaughtException` FACT trap — which would violate contracts/intrinsics.md
+ * §"Universal semantics" 2 ("traps ... must not be catchable by guest code").
+ *
+ * The fix is to remember the trap on the way out and restore it when the
+ * barrier reports `UncaughtException`. A genuine guest exception leaves
+ * `pending` untouched and keeps the generic trap.
+ *
+ * **Residual limitation (inherent to a JS host).** wasmtime's traps are
+ * unforgeable and uncatchable: they unwind out of band, and no guest
+ * construct can observe or swallow one. Ours are ordinary JS exceptions, so
+ * a guest that wraps a call in its own `try_table (catch_all …)` *can* catch
+ * a host trap mid-flight and continue — the Component Model says that must be
+ * impossible. Recovering full unforgeability needs an out-of-band channel
+ * (e.g. a poison flag consulted at every host boundary crossing) and is not
+ * attempted here; the barrier case above is the one that occurs in practice,
+ * because FACT emits it on every adapter. Recorded as a known gap.
+ */
+export interface HostTrapState {
+    pending: unknown;
+}
+export { UnsupportedFeatureError } from "./errors.js";
+/**
+ * The borrow bookkeeping of one in-flight synchronous cross-component call,
+ * bracketed by the FACT adapter's `enter-sync-call` / `exit-sync-call`
+ * imports (wasmtime-environ 47.0.3 `fact/trampoline.rs:810,904`: enter is
+ * emitted *before* argument translation and exit *after* the callee returns,
+ * so every resource transfer for the call happens inside the bracket).
+ *
+ * It plays the role definitions.py gives the callee `Subtask`/`Task`:
+ *
+ *  - `lenders` — handles lent to the callee (`Subtask.lenders`); each
+ *    `num_lends` is dropped again when the call returns, which is what makes
+ *    a lender's own handle liftable again afterwards.
+ *  - `numBorrows` — borrow handles lowered into the callee's table
+ *    (`Task.num_borrows`); the callee must drop them all before returning
+ *    (definitions.py `Task.return_`: `trap_if(self.num_borrows > 0)`).
+ *
+ * Structurally satisfies cabi's `TaskBorrowScope` and `SubtaskBorrowScope`.
+ */
+export declare class SyncCallScope {
+    numBorrows: number;
+    readonly lenders: ResourceHandle[];
+    /**
+     * definitions.py `Subtask.add_lender` (line 890) — note there is **no**
+     * `own` check, and `lift_borrow` (line 1516) calls it unconditionally: a
+     * component that received a borrow may lend it onward, and the borrow
+     * handle's own `num_lends` is what blocks `resource.drop` on it until the
+     * onward call returns (`canon_resource_drop`, line 2325, traps on
+     * `num_lends != 0` for owning *and* borrowed handles alike).
+     * wasmtime 47.0.3 `vm/component/resources.rs:285` (`resource_lift_borrow`)
+     * agrees.
+     */
+    addLender(h: ResourceHandle): void;
+    /** definitions.py `Subtask.deliver_resolve` (lines 902-906): releases lenders at delivery time. */
+    releaseLenders(): void;
+}
+/**
+ * The borrow bookkeeping of one FACT `[async-start]` argument-copy window —
+ * the prepare/start protocol's analogue of `SyncCallScope`. Live only for
+ * the synchronous `callCore(prepared.start, …)` call inside `mkCalleeTask`'s
+ * `on_start` (the copy adapters cannot block, so the window never suspends).
+ *
+ * Reference mapping (definitions.py): `taskScope` is the callee `Task` —
+ * `lower_borrow` (line 1821) counts `num_borrows` there, and
+ * `Task.return_`/`cancel` trap while it is non-zero; `lenders` is the
+ * caller-side `Subtask` (async-start-call) or a plain scope released when
+ * the caller's blocked frame gets its results (sync-start-call) —
+ * `lift_borrow` (line 1517) adds lenders there, released at
+ * `deliver_resolve` (line 904). Found by the #18 polymorph-tls smoke: the
+ * suite is the first corpus with borrow-carrying composed calls through
+ * prepare/start adapters, which previously asserted "transfer-borrow
+ * outside an enter-sync-call/exit-sync-call bracket".
+ */
+export interface FactStartScope {
+    /** The callee task (satisfies cabi's `TaskBorrowScope`). */
+    taskScope: import("../cabi/context.js").TaskBorrowScope;
+    /** The caller-side lender registrar (satisfies `SubtaskBorrowScope`). */
+    lenders: {
+        addLender(h: ResourceHandle): void;
+    };
+}
+/** Executor services a trampoline body needs (provided by executor.ts). */
+export interface TrampolineContext {
+    componentInstance(index: number): ComponentInstanceState;
+    resourceToken(index: number): ResourceTypeInfo;
+    /**
+     * The component instance that *owns* resource table `index`
+     * (`TypeResourceTable::Concrete.instance`), i.e. whose handle table the
+     * FACT transfer intrinsics move handles between. Throws for abstract
+     * (type-only) tables, which have no runtime state.
+     */
+    resourceTableInstance(index: number): ComponentInstanceState;
+    /**
+     * A live view of runtime memory `index` (`RuntimeMemoryIndex`), for the
+     * string-transcoder trampolines.
+     */
+    runtimeMemory(index: number): TranscodeMemory;
+    /**
+     * Stack of in-flight synchronous cross-component calls (innermost last),
+     * owned by the executor so all trampolines of one instantiation share it.
+     */
+    syncCallStack: SyncCallScope[];
+    /**
+     * Stack of in-flight FACT `[async-start]` argument-copy windows (innermost
+     * last; see `FactStartScope`). Separate from `syncCallStack` because the
+     * prepare/start protocol has no enter/exit-sync-call bracket — the borrow
+     * bookkeeping attaches to the callee `Task` and the caller-side subtask
+     * instead (definitions.py `lower_borrow` line 1821 / `lift_borrow` line
+     * 1517).
+     */
+    factStartScopes: FactStartScope[];
+    /** See `FactCallContext.calleeCanBlock` (intrinsics/fact_calls.ts). */
+    calleeCanBlock?(fn: unknown): boolean;
+    /** See `HostTrapState`. */
+    trapState: HostTrapState;
+    /**
+     * Resolved canonical options by index, and the element types of an interned
+     * results tuple — needed by the async built-ins (task.return,
+     * waitable-set.{wait,poll}). See `AsyncTrampolineContext`.
+     */
+    options(index: number): import("../exec/boundary.js").ResolvedOptions;
+    resultTypes(index: number): import("../cabi/types.js").ValType[];
+    /** `RuntimeCallbackIndex` -> the extracted callback core function. */
+    callback(index: number): CoreFn;
+    /** `RuntimeMemoryIndex` -> an identity token for `task.return` checks. */
+    memoryToken(index: number): unknown;
+    /** The single in-flight FACT preparation (see `PreparedCall`). */
+    prepared: {
+        current: PreparedCall | null;
+    };
+    /** Suspension discipline (jspi/bridge.ts). */
+    suspensionMode: import("../jspi/mod.js").SuspensionMode;
+    /** Element types of the plan v2 stream/future tables. */
+    streamElem(index: number): import("../cabi/types.js").ValType | null;
+    futureElem(index: number): import("../cabi/types.js").ValType | null;
+    streamTableInstance(index: number): ComponentInstanceState;
+    futureTableInstance(index: number): ComponentInstanceState;
+    /**
+     * The component instance owning error-context table `index`
+     * (`TypeComponentLocalErrorContextTableIndex`, plan v3 `errorContextTables`).
+     * Its own index space — NOT the resource-table one it used to borrow.
+     */
+    errorContextTableInstance(index: number): ComponentInstanceState;
+    /**
+     * Element types of the *raw* wasmtime `TypeTupleIndex` FACT's
+     * `prepare-call` passes as `task_return_type`, or `null` when the plan
+     * carries no mapping for it (see `LoadedPlan.resultTupleTypes`).
+     */
+    resultTypesForTuple(tupleIndex: number): import("../cabi/types.js").ValType[] | null;
+    /** Build the lowered-import body for `lowered` (LoweredIndex). */
+    loweredImport(decl: {
+        lowered: number;
+        options: number;
+        type: number;
+    }): CoreFn;
+    stats: ExecutionStats;
+}
+/**
+ * Create the JS function backing one plan trampoline. Called during
+ * initializer/arg/export resolution — i.e. at instantiate time — so an
+ * unsupported kind fails instantiation, not the first call
+ * (plan-format.md "Executor obligations"). Unreferenced trampolines are
+ * never created and therefore never fail (intrinsics.md §B tolerates e.g.
+ * an unreferenced task-return until M2).
+ */
+export declare function createTrampoline(decl: WireTrampoline, ctx: TrampolineContext): CoreFn;

package/types/intrinsics/stream_builtins.d.ts

@@ -0,0 +1,113 @@
+import type { SuspensionMode } from "../jspi/mod.js";
+import type { ValType } from "../cabi/types.js";
+import { type ComponentInstanceState } from "../task/mod.js";
+import { type CoreFn, type ResolvedOptions } from "../exec/boundary.js";
+export declare function traceCopy(msg: string): void;
+/** Services the stream/future built-ins need from the executor. */
+export interface StreamTrampolineContext {
+    componentInstance(index: number): ComponentInstanceState;
+    options(index: number): ResolvedOptions;
+    /** Element type of a `TypeStreamTableIndex` (plan v2 `streamTables`). */
+    streamElem(index: number): ValType | null;
+    /** Element type of a `TypeFutureTableIndex` (plan v2 `futureTables`). */
+    futureElem(index: number): ValType | null;
+    /** Suspension discipline; decides whether site 4 blocks or signals. */
+    suspensionMode?: SuspensionMode;
+}
+/**
+ * definitions.py `canon_stream_new` (line 2504) / `canon_future_new` (2512).
+ * Returns both handles packed into an i64: `ri | (wi << 32)`.
+ */
+export declare function createStreamNew(decl: {
+    streamTable: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createFutureNew(decl: {
+    futureTable: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+/**
+ * definitions.py `canon_error_context_new` (line 2778).
+ *
+ * The reference is deliberately non-committal about the message: under
+ * `DETERMINISTIC_PROFILE` it stores the empty string, otherwise it may apply a
+ * `host_defined_transformation`. We keep the guest's message verbatim — the
+ * most useful behaviour for a debugging aid, and within what the spec allows
+ * (the message is explicitly not semantically load-bearing).
+ */
+export declare function createErrorContextNew(decl: {
+    options: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+/** definitions.py `canon_error_context_debug_message` (line 2792). */
+export declare function createErrorContextDebugMessage(decl: {
+    options: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+/** definitions.py `canon_error_context_drop` (line 2803). */
+export declare function createErrorContextDrop(inst: ComponentInstanceState): CoreFn;
+export declare function createStreamRead(d: {
+    streamTable: number;
+    options: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createStreamWrite(d: {
+    streamTable: number;
+    options: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createFutureRead(d: {
+    futureTable: number;
+    options: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createFutureWrite(d: {
+    futureTable: number;
+    options: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createStreamCancelRead(d: {
+    streamTable: number;
+    async: boolean;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createStreamCancelWrite(d: {
+    streamTable: number;
+    async: boolean;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createFutureCancelRead(d: {
+    futureTable: number;
+    async: boolean;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createFutureCancelWrite(d: {
+    futureTable: number;
+    async: boolean;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createStreamDropReadable(d: {
+    streamTable: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createStreamDropWritable(d: {
+    streamTable: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createFutureDropReadable(d: {
+    futureTable: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+export declare function createFutureDropWritable(d: {
+    futureTable: number;
+}, ctx: StreamTrampolineContext, inst: ComponentInstanceState): CoreFn;
+/** Services the transfer intrinsics need beyond `StreamTrampolineContext`. */
+export interface AsyncTransferContext extends StreamTrampolineContext {
+    streamTableInstance(index: number): ComponentInstanceState;
+    futureTableInstance(index: number): ComponentInstanceState;
+}
+export declare function createStreamTransfer(ctx: AsyncTransferContext): CoreFn;
+export declare function createFutureTransfer(ctx: AsyncTransferContext): CoreFn;
+/**
+ * error-context transfer. Unlike stream/future ends, an `error-context` is
+ * shareable: `lift_error_context` (definitions.py line 1451) *reads* the handle
+ * rather than removing it, so the source keeps its own.
+ */
+/**
+ * Plan v3 (contracts/plan-format.md v3 amendment 2): `instanceOf` resolves
+ * through the plan's `errorContextTables` section — the
+ * `TypeComponentLocalErrorContextTableIndex` space these arguments actually
+ * live in. It replaced a resource-table lookup, which shared neither the
+ * index space nor (in a multi-instance composition) the answer.
+ *
+ * The arguments are the trampoline's own core parameters, so a missing one is
+ * an arity fault, not a zero: no `?? 0` defaults — `instanceOf(undefined!)`
+ * would be a silent table-0 read. `assert_` instead, and the accessor itself
+ * raises a `PlanError` for an out-of-range table.
+ */
+export declare function createErrorContextTransfer(ctx: AsyncTransferContext, instanceOf: (table: number) => ComponentInstanceState): CoreFn;

package/types/intrinsics/transcode.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A live view of one `WebAssembly.Memory`. Views are re-derived per access:
+ * a transcoder can be called after the guest grew a memory, which detaches
+ * the previous `ArrayBuffer`.
+ */
+export declare class TranscodeMemory {
+    #private;
+    constructor(provider: () => WebAssembly.Memory | undefined, label: string);
+    bytes(): Uint8Array;
+}
+/** The `Transcode` op names as emitted by the shim (`Transcode::desc()`). */
+export type TranscodeOp = "utf8-to-utf8" | "utf16-to-utf16" | "latin1-to-latin1" | "latin1-to-utf16" | "latin1-to-utf8" | "utf16-to-compact-probably-utf16" | "utf16-to-compact-utf16" | "utf16-to-latin1" | "utf16-to-utf8" | "utf8-to-compact-utf16" | "utf8-to-latin1" | "utf8-to-utf16";
+export declare const TRANSCODE_OPS: readonly TranscodeOp[];
+/**
+ * Build the JS function backing one `Transcoder` trampoline.
+ *
+ * Result shape follows the core signature in `fact/transcode.rs`: no result,
+ * one result (a number), or two results (a `[srcRead, dstWritten]` pair — the
+ * JS API delivers a multi-value return as an array).
+ */
+export declare function createTranscoder(op: TranscodeOp, from: TranscodeMemory, to: TranscodeMemory): (...args: number[]) => unknown;