@boundaryml/baml-bridge-web 0.0.0

package/dist/wasm/bridge_web_core.d.ts

@@ -0,0 +1,174 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+
+export type ReadableStreamType = "bytes";
+
+export class IntoUnderlyingByteSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableByteStreamController): Promise<any>;
+    start(controller: ReadableByteStreamController): void;
+    readonly autoAllocateChunkSize: number;
+    readonly type: ReadableStreamType;
+}
+
+export class IntoUnderlyingSink {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abort(reason: any): Promise<any>;
+    close(): Promise<any>;
+    write(chunk: any): Promise<any>;
+}
+
+export class IntoUnderlyingSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableStreamDefaultController): Promise<any>;
+}
+
+export function callFunction(function_name: string, encoded_args: Uint8Array): Promise<Uint8Array>;
+
+export function callFunctionSync(function_name: string, encoded_args: Uint8Array): Uint8Array;
+
+export function cancelFunctionCall(call_id: bigint): boolean;
+
+/**
+ * Complete an in-flight host call from JS.
+ *
+ * Exposed to JS as `completeHostCall(callId, isError, content)`.
+ *
+ * On success (`is_error == 0`), `content` is a protobuf-encoded `InboundValue`
+ * (host→engine direction, no type metadata — engine re-validates against the
+ * declared return type).
+ *
+ * On error (`is_error != 0`), `content` is a protobuf-encoded `InboundValue`
+ * representing the thrown value. The host bridge SDK wraps native exceptions
+ * in a synthetic `Instance` of class `baml.errors.HostCallable` carrying
+ * `message` / `class_name` / `language` / `traceback` fields; codegenned
+ * BAML errors flow through as their own `Instance` shape. The engine's
+ * `materialize_host_throw` runs the declared-throws contract check on the
+ * decoded value and either re-injects it as a catchable throw or escalates
+ * to a `HostContractViolation` panic.
+ *
+ * `call_id` is globally unique, so it resolves the originating runtime's
+ * pending call unambiguously. If `call_id` is unknown the call is silently
+ * dropped (likely a stale completion racing with a cancellation).
+ */
+export function completeHostCall(call_id: number, is_error: number, content: Uint8Array): void;
+
+export function completeWebHostCall(call_id: number, is_error: number, content: Uint8Array): void;
+
+/**
+ * Mint a key for a JS-owned opaque value from the same keyspace used by
+ * callable host values. Both kinds share one engine handle table.
+ */
+export function mintHostValueKey(): bigint;
+
+export function mintWebHostValueKey(): bigint;
+
+export function newFunctionCall(): bigint;
+
+/**
+ * Register a JS callable in the WASM host-value table and return its key.
+ *
+ * Exposed to JS as `registerHostCallable(fn) -> bigint`. The key is then
+ * embedded in `InboundValue::Handle { key, handleType: HOST_VALUE_CALLABLE }`
+ * by the JS encoder. The returned value is a `BigInt` because `u64` does not
+ * fit into JS's safe-integer range.
+ */
+export function registerHostCallable(callable: Function): bigint;
+
+/**
+ * Register the JS callback that releases opaque values from the SDK's local
+ * registry when the engine drops its last corresponding `HostValueArc`.
+ */
+export function registerHostValueReleaseCallback(callback: Function): void;
+
+export function registerWebHostCallable(callable: Function): bigint;
+
+export function registerWebHostValueReleaseCallback(callback: Function): void;
+
+/**
+ * Remove a callable that was registered but never transferred to the engine.
+ */
+export function releaseHostCallable(key: bigint): void;
+
+export function releaseWebHostCallable(key: bigint): void;
+
+export function stageRuntimeBytecode(bytecode: Uint8Array, callbacks: any): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly callFunction: (a: number, b: number, c: number, d: number) => number;
+    readonly callFunctionSync: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly cancelFunctionCall: (a: bigint) => number;
+    readonly completeWebHostCall: (a: number, b: number, c: number, d: number) => void;
+    readonly mintWebHostValueKey: () => bigint;
+    readonly newFunctionCall: () => bigint;
+    readonly registerWebHostCallable: (a: number) => bigint;
+    readonly registerWebHostValueReleaseCallback: (a: number) => void;
+    readonly releaseWebHostCallable: (a: bigint) => void;
+    readonly stageRuntimeBytecode: (a: number, b: number, c: number, d: number) => void;
+    readonly completeHostCall: (a: number, b: number, c: number, d: number) => void;
+    readonly registerHostCallable: (a: number) => bigint;
+    readonly registerHostValueReleaseCallback: (a: number) => void;
+    readonly releaseHostCallable: (a: bigint) => void;
+    readonly mintHostValueKey: () => bigint;
+    readonly __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsink_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
+    readonly intounderlyingbytesource_cancel: (a: number) => void;
+    readonly intounderlyingbytesource_pull: (a: number, b: number) => number;
+    readonly intounderlyingbytesource_start: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_type: (a: number) => number;
+    readonly intounderlyingsink_abort: (a: number, b: number) => number;
+    readonly intounderlyingsink_close: (a: number) => number;
+    readonly intounderlyingsink_write: (a: number, b: number) => number;
+    readonly intounderlyingsource_cancel: (a: number) => void;
+    readonly intounderlyingsource_pull: (a: number, b: number) => number;
+    readonly __wasm_bindgen_func_elem_37361: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_37369: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_1351: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_1130: (a: number, b: number) => void;
+    readonly __wbindgen_export: (a: number) => void;
+    readonly __wbindgen_export2: (a: number, b: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export4: (a: number, b: number) => void;
+    readonly __wbindgen_export5: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;