edge-intelligence-sdk 0.3.7

package/src/rn/el_ffi.ts

@@ -0,0 +1,545 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import nativeModule from "./el_ffi-ffi";
+import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct, type UniffiVTableCallbackInterfaceElFfiStreamHandler,
+} from "./el_ffi-ffi";
+import { type FfiConverter, type UniffiByteArray, type UniffiGcObject, type UniffiHandle, type UniffiObjectFactory, type UniffiReferenceHolder, type UniffiRustCallStatus, AbstractFfiConverterByteArray, FfiConverterCallback, FfiConverterInt32, FfiConverterObject, FfiConverterUInt8, RustBuffer, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiTraitInterfaceCall, uniffiTypeNameSymbol, variantOrdinalSymbol,
+} from "@ubjs/core";
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+
+// Public interface members begin here.
+
+// Hermes (React Native ≥ 0.74) ships TextEncoder and encodeInto, but not
+// TextDecoder. For single-string decode (bytesToString), we polyfill via the
+// C++ string_from_buffer helper using a duck-typed object matching the
+// standard TextDecoder.decode signature. Once Hermes ships a real
+// TextDecoder, the `typeof` check will pick it up automatically.
+//
+// For array-of-strings decode (readStringFromBuffer), we keep a dedicated C++
+// helper: the polyfill path (new Uint8Array view + decode) measured ~40%
+// slower on getStringArray benchmarks than a direct (buf, offset, length)
+// call, due to the per-read view allocation and extra property lookups in
+// string_from_buffer.
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder: { decode(input: UniffiByteArray): string } =
+        typeof TextDecoder !== "undefined"
+            ? new TextDecoder()
+            : {
+                  decode: (bytes: UniffiByteArray) =>
+                      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_from_buffer(
+                          bytes,
+                          undefined as any,
+                      ) as string,
+              };
+    return {
+        // Single-string lower() uses the C++ helper — TextEncoder.encode
+        // measured ~43% slower on takeString benchmarks.
+        stringToBytes: (s: string) =>
+            nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_buffer(s, undefined as any),
+        bytesToString: (ab: UniffiByteArray) => decoder.decode(ab),
+        // Direct C++ call — bypasses uniffiCaller.rustCall() overhead.
+        // Matters for N-element arrays.
+        stringByteLength: (s: string) =>
+            nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, undefined as any) as number,
+        // Encode directly into the RustBuffer backing store via
+        // TextEncoder.encodeInto — zero intermediate allocation. Replaces
+        // the old C++ write_string_into_buffer helper.
+        writeStringIntoBuffer: (s: string, buf: any, offset: number): number => {
+            const view = new Uint8Array(
+                buf.arrayBuffer,
+                offset,
+                buf.arrayBuffer.byteLength - offset,
+            );
+            return encoder.encodeInto(s, view).written;
+        },
+        // Dedicated C++ helper — avoids per-read Uint8Array allocation and
+        // the double property-lookup in string_from_buffer.
+        readStringFromBuffer: (buf: any, offset: number, length: number): string =>
+            nativeModule().ubrn_uniffi_internal_fn_func_ffi__read_string_from_buffer(buf, offset, length) as string,
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+
+// Error type: SdkError
+export enum SdkError_Tags {
+    ProviderError = "ProviderError"
+}
+/**
+ * Error returned across the FFI boundary.
+ *
+ * On **native** (non-wasm32): `#[uniffi::Error]` projects this to the host
+ * language's exception type (TS `Error`, Kotlin `Exception`, Swift `Error`).
+ * On **wasm32**: converted to a JS exception via `JsValue` at the
+ * `ask_wasm` call site.
+ *
+ * Design note: `EdgeError` from el-core is not directly FFI-safe (uses
+ * `Box<str>` and Rust-specific variants). `SdkError` is a thin projection.
+ */
+export const SdkError = (() => {
+
+    type ProviderError__interface = {
+        tag: SdkError_Tags.ProviderError;
+        inner: 
+Readonly<{message: string}>
+    };
+    /**
+     * The LLM backend (local Candle or cloud) returned an error.
+     */
+    class ProviderError_ extends UniffiError implements ProviderError__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "SdkError";
+        readonly tag = SdkError_Tags.ProviderError;
+        readonly inner: 
+Readonly<{message: string}>;
+        constructor(
+inner: {message: string }) {
+            super("SdkError", "ProviderError");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {message: string }): ProviderError_ {
+            return new ProviderError_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ProviderError_ {
+            return obj.tag === SdkError_Tags.ProviderError;
+        }
+        static hasInner(obj: any): obj is ProviderError_ {
+            return ProviderError_.instanceOf(obj);
+        }
+
+        static getInner(obj: ProviderError_): 
+Readonly<{message: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is SdkError {
+        return obj[uniffiTypeNameSymbol] === "SdkError";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  ProviderError: ProviderError_
+    });
+
+})();
+/**
+ * Error returned across the FFI boundary.
+ *
+ * On **native** (non-wasm32): `#[uniffi::Error]` projects this to the host
+ * language's exception type (TS `Error`, Kotlin `Exception`, Swift `Error`).
+ * On **wasm32**: converted to a JS exception via `JsValue` at the
+ * `ask_wasm` call site.
+ *
+ * Design note: `EdgeError` from el-core is not directly FFI-safe (uses
+ * `Box<str>` and Rust-specific variants). `SdkError` is a thin projection.
+ */
+export type SdkError = InstanceType<
+    typeof SdkError['ProviderError']
+>;
+
+// FfiConverter for enum SdkError
+const FfiConverterTypeSdkError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = SdkError;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new SdkError.ProviderError({message: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case SdkError_Tags.ProviderError: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.message, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that SdkError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case SdkError_Tags.ProviderError: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.message);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+/**
+ * Token-by-token callback for streaming on React Native.
+ *
+ * Implement on the TS/Kotlin/Swift side and pass to
+ * [`EdgeLlm::ask_stream_cb`]. Each call delivers one text fragment; the
+ * method returns (and calls nothing more) when generation is complete.
+ *
+ * Flutter uses the closure-based [`EdgeLlm::ask_stream`] instead.
+ */
+export interface StreamHandler {
+    
+    onToken(token: string): void;
+}
+
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceStreamHandler: { vtable: any; register: () => void; } = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        on_token: (
+            uniffiHandle: bigint,
+            token: Uint8Array,) => {
+            const uniffiMakeCall = 
+            ()
+            : void => {
+                const jsCallback = FfiConverterTypeStreamHandler.lift(uniffiHandle);
+                return jsCallback.onToken(
+                    FfiConverterString.lift(token)
+                )
+            };
+            const uniffiResult = UniffiResult.ready<void>();
+            const uniffiHandleSuccess = (obj: any) => {};
+            const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+                UniffiResult.writeError(uniffiResult, code, errBuf);
+            };
+            uniffiTraitInterfaceCall(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            )
+            return uniffiResult;
+        },
+        uniffi_free: (uniffiHandle: UniffiHandle): void => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeStreamHandler.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle: UniffiHandle): UniffiHandle => {
+            return FfiConverterTypeStreamHandler.clone(uniffiHandle);
+        }
+    },
+    register: () => {nativeModule().ubrn_uniffi_el_ffi_fn_init_callback_vtable_streamhandler(
+            uniffiCallbackInterfaceStreamHandler.vtable
+        );
+    },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeStreamHandler = new FfiConverterCallback<StreamHandler>();
+
+/**
+ * The flat FFI-friendly facade (ADR-001, ADR-009, ADR-010).
+ *
+ * Annotated for all three binding surfaces:
+ * - `uniffi::Object` (native) → opaque UniFFI / React Native handle
+ * - `frb(opaque)` (native) → opaque Flutter/Dart handle via FRB v2
+ * - `wasm_bindgen` (wasm32) → satisfies `IntoWasmAbi`/`WasmDescribe` so
+ * that `#[wasm_bindgen] impl EdgeLlm { ... }` compiles
+ */
+export interface EdgeLlmLike {
+    
+/**
+ * Blocking chat completion.
+ *
+ * Returns `Err(SdkError::ProviderError)` on network/auth/engine failure
+ * so callers can distinguish model output from error conditions.
+ */
+    ask(prompt: string) /*throws*/: string;
+/**
+ * Stream tokens to a [`StreamHandler`] callback (React Native path).
+ *
+ * Returns an error on network/auth/engine failure so callers are not
+ * left waiting for a stream that will never arrive.
+ */
+    askStreamCb(prompt: string, handler: StreamHandler) /*throws*/: void;
+/**
+ * Reset the session (clears KV cache and output).
+ */
+    reset(): void;
+}
+/**
+ * @deprecated Use `EdgeLlmLike` instead.
+ */
+export type EdgeLlmInterface = EdgeLlmLike;
+
+
+/**
+ * The flat FFI-friendly facade (ADR-001, ADR-009, ADR-010).
+ *
+ * Annotated for all three binding surfaces:
+ * - `uniffi::Object` (native) → opaque UniFFI / React Native handle
+ * - `frb(opaque)` (native) → opaque Flutter/Dart handle via FRB v2
+ * - `wasm_bindgen` (wasm32) → satisfies `IntoWasmAbi`/`WasmDescribe` so
+ * that `#[wasm_bindgen] impl EdgeLlm { ... }` compiles
+ */
+export class EdgeLlm extends UniffiAbstractObject implements EdgeLlmLike {
+
+    readonly [uniffiTypeNameSymbol] = "EdgeLlm";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeEdgeLlmObjectFactory.bless(pointer);
+}
+
+    
+/**
+ * Construct with a frontier cloud backend (opt-in, ADR-010).
+ *
+ * `model` uses the routing prefix: `"openai/gpt-4o"`,
+ * `"anthropic/claude-sonnet-4-6"`, `"ollama/llama3"`,
+ * `"gemini/gemini-2.0-flash"`, or any OpenAI-compat base URL.
+ * `api_key` must come from the platform keystore — never embedded.
+ *
+ * **Native only** (React Native / Flutter). On wasm32 this constructor
+ * does not exist — the web surface exposes a throwing `cloud` instead
+ * (see the wasm32 impl block below and the ADR-010 amendment).
+ */
+    static cloud(model: string, apiKey: string): EdgeLlmLike {
+    return FfiConverterTypeEdgeLlm.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_el_ffi_fn_constructor_edgellm_cloud(
+        FfiConverterString.lower(model, nativeModule().rustbuffer_alloc),
+        FfiConverterString.lower(apiKey, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+    
+/**
+ * Construct with the local Candle engine (air-gapped, ADR-002/004).
+ *
+ * If `model_uri` is non-empty, loads the GGUF at that path via
+ * `CandleEngine::from_path` (consumer-supplied model, ADR-002).
+ * Pass an empty string to use a deterministic toy model for development
+ * and testing — the toy generates gibberish but exercises the full
+ * binding layer end-to-end.
+ *
+ * Returns `Err(SdkError)` if `model_uri` is non-empty but the file
+ * cannot be parsed (missing, malformed GGUF, incompatible tensor shapes).
+ * An empty `model_uri` never fails.
+ *
+ * The permissive signature verifier used here is intentional: it lets the
+ * binding layer be exercised without a signed model artifact. A production
+ * deployment should substitute a real `SignatureVerifier` backed by the
+ * platform keystore.
+ */
+    static local(modelUri: string): EdgeLlmLike /*throws*/ {
+    return FfiConverterTypeEdgeLlm.lift(uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_el_ffi_fn_constructor_edgellm_local(
+        FfiConverterString.lower(modelUri, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+    
+
+    
+/**
+ * Blocking chat completion.
+ *
+ * Returns `Err(SdkError::ProviderError)` on network/auth/engine failure
+ * so callers can distinguish model output from error conditions.
+ */
+    ask(prompt: string): string /*throws*/ {
+    return ((__rb: Uint8Array) => {
+        try {
+            return FfiConverterString.lift(__rb);
+        } finally {
+            nativeModule().rustbuffer_free(__rb);
+        }
+    })(uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_el_ffi_fn_method_edgellm_ask(
+                uniffiTypeEdgeLlmObjectFactory.clonePointer(this),
+        FfiConverterString.lower(prompt, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+    
+/**
+ * Stream tokens to a [`StreamHandler`] callback (React Native path).
+ *
+ * Returns an error on network/auth/engine failure so callers are not
+ * left waiting for a stream that will never arrive.
+ */
+    askStreamCb(prompt: string, handler: StreamHandler): void /*throws*/ {uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError),
+            /*caller:*/ (callStatus) => { nativeModule().ubrn_uniffi_el_ffi_fn_method_edgellm_ask_stream_cb(
+                uniffiTypeEdgeLlmObjectFactory.clonePointer(this),
+        FfiConverterString.lower(prompt, nativeModule().rustbuffer_alloc),
+        FfiConverterTypeStreamHandler.lower(handler, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    }
+    
+/**
+ * Reset the session (clears KV cache and output).
+ */
+    reset(): void {uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => { nativeModule().ubrn_uniffi_el_ffi_fn_method_edgellm_reset(
+                uniffiTypeEdgeLlmObjectFactory.clonePointer(this),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    }
+    
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeEdgeLlmObjectFactory.pointer(this);
+            uniffiTypeEdgeLlmObjectFactory.freePointer(pointer);
+            uniffiTypeEdgeLlmObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is EdgeLlm {
+        return uniffiTypeEdgeLlmObjectFactory.isConcreteType(obj_);
+    }
+
+    
+}
+
+const uniffiTypeEdgeLlmObjectFactory: UniffiObjectFactory<EdgeLlmLike> = (() => {
+    
+    return {
+    create(pointer: UniffiHandle): EdgeLlmLike {
+        const instance = Object.create(EdgeLlm.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "EdgeLlm";
+        return instance;
+    },
+
+    
+    bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+            /*caller:*/ (status) =>
+                nativeModule().ubrn_uniffi_internal_fn_method_edgellm_ffi__bless_pointer(p, status),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        ptr_.markDestroyed();
+    },
+
+    pointer(obj_: EdgeLlmLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: EdgeLlmLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_el_ffi_fn_clone_edgellm(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_el_ffi_fn_free_edgellm(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is EdgeLlmLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "EdgeLlm";
+    },
+}})();
+const FfiConverterTypeEdgeLlm = new FfiConverterObject(uniffiTypeEdgeLlmObjectFactory);
+
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ubrn_ffi_el_ffi_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().ubrn_uniffi_el_ffi_checksum_constructor_edgellm_cloud() !== 15440) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_el_ffi_checksum_constructor_edgellm_cloud");
+    }
+    if (nativeModule().ubrn_uniffi_el_ffi_checksum_constructor_edgellm_local() !== 50108) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_el_ffi_checksum_constructor_edgellm_local");
+    }
+    if (nativeModule().ubrn_uniffi_el_ffi_checksum_method_edgellm_ask() !== 5083) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_el_ffi_checksum_method_edgellm_ask");
+    }
+    if (nativeModule().ubrn_uniffi_el_ffi_checksum_method_edgellm_ask_stream_cb() !== 532) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_el_ffi_checksum_method_edgellm_ask_stream_cb");
+    }
+    if (nativeModule().ubrn_uniffi_el_ffi_checksum_method_edgellm_reset() !== 31815) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_el_ffi_checksum_method_edgellm_reset");
+    }
+
+    uniffiCallbackInterfaceStreamHandler.register();
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeEdgeLlm,
+    FfiConverterTypeSdkError,
+  }
+});

package/src/web/el_ffi.d.ts

@@ -0,0 +1,68 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The flat FFI-friendly facade (ADR-001, ADR-009, ADR-010).
+ *
+ * Annotated for all three binding surfaces:
+ * - `uniffi::Object` (native) → opaque UniFFI / React Native handle
+ * - `frb(opaque)` (native) → opaque Flutter/Dart handle via FRB v2
+ * - `wasm_bindgen` (wasm32) → satisfies `IntoWasmAbi`/`WasmDescribe` so
+ *   that `#[wasm_bindgen] impl EdgeLlm { ... }` compiles
+ */
+export class EdgeLlm {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Blocking chat; throws a JS Error on provider failure.
+     */
+    ask_wasm(prompt: string): string;
+    /**
+     * Frontier cloud backend is **not yet available on web** (ADR-010):
+     * `el-cloud`'s blocking HTTP transport has no wasm implementation, and
+     * the synchronous `LlmProvider` trait cannot await the browser's async
+     * `fetch`. Always throws so callers fail loudly instead of silently
+     * receiving an echo stub. Use a native binding (React Native / Flutter)
+     * for cloud access.
+     */
+    static cloud(_model: string, _api_key: string): EdgeLlm;
+    constructor(model_uri: string);
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_edgellm_free: (a: number, b: number) => void;
+    readonly edgellm_ask_wasm: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly edgellm_cloud: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly edgellm_new_local: (a: number, b: number) => [number, number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+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>;