@independo/capacitor-inderun 1.0.1-dev.1 → 1.1.0-dev.10

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+import { type IndeRunError } from "@independo/inderun-contracts";
+/**
+ * Unwraps whatever the Capacitor boundary hands back into the canonical
+ * `IndeRunError` the native side rejected with.
+ *
+ * Capacitor wraps a native rejection's structured data under `error.data`, so a
+ * thrown value is either already an `IndeRunError` (the web implementation throws
+ * one directly) or carries one there. Anything else is passed through untouched
+ * rather than guessed at.
+ */
+export declare function normalizePluginError(error: unknown): unknown;
+/**
+ * Mints an `IndeRunError` for a failure of the bridge itself — event loss across
+ * the JS boundary, a malformed handle — as opposed to one reported by a provider
+ * or the engine. `Internal` is the correct class: nothing about the request or the
+ * provider is at fault, the transport is.
+ */
+export declare function createBridgeError(message: string, runId?: string): IndeRunError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEvF;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAe5D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY,CAO/E"}

package/dist/errors.js

@@ -0,0 +1,36 @@
+import { validateIndeRunError } from "@independo/inderun-contracts";
+/**
+ * Unwraps whatever the Capacitor boundary hands back into the canonical
+ * `IndeRunError` the native side rejected with.
+ *
+ * Capacitor wraps a native rejection's structured data under `error.data`, so a
+ * thrown value is either already an `IndeRunError` (the web implementation throws
+ * one directly) or carries one there. Anything else is passed through untouched
+ * rather than guessed at.
+ */
+export function normalizePluginError(error) {
+    if (validateIndeRunError(error)) {
+        return error;
+    }
+    if (typeof error === "object" &&
+        error !== null &&
+        "data" in error &&
+        validateIndeRunError(error.data)) {
+        return error.data;
+    }
+    return error;
+}
+/**
+ * Mints an `IndeRunError` for a failure of the bridge itself — event loss across
+ * the JS boundary, a malformed handle — as opposed to one reported by a provider
+ * or the engine. `Internal` is the correct class: nothing about the request or the
+ * provider is at fault, the transport is.
+ */
+export function createBridgeError(message, runId) {
+    return {
+        schemaVersion: "1.0",
+        errorClass: "Internal",
+        message,
+        ...(runId !== undefined ? { runId } : {})
+    };
+}

package/dist/index.d.ts

@@ -1,10 +1,23 @@
-import { type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
-import type { ConfigureOptions, IndeRunCapacitorPlugin as IndeRunCapacitorPluginContract, OpenAIProviderBootstrapOptions } from "./definitions.js";
-export declare const IndeRunCapacitor: IndeRunCapacitorPluginContract;
+import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+import type { CancelStreamOptions, CheckCapabilitiesResult, ConfigureOptions, IndeRunCapacitorPlugin as IndeRunCapacitorPluginContract, OnnxProviderBootstrapOptions, OpenAIProviderBootstrapOptions, ProviderCapabilitySnapshot, ProviderDescriptor, ProviderDynamicCapabilities, StartStreamOptions, StreamErrorNotification, StreamEventNotification, StreamRun, SystemModelProviderBootstrapOptions } from "./definitions.js";
+/**
+ * The plugin contract plus the ergonomic Mode 2 entry point. `stream()` is not a
+ * plugin method — it is `startStream`, the event listeners, and `cancelStream`
+ * reassembled into the same shape the platform SDKs return from `stream()`.
+ */
+export interface IndeRunCapacitorApi extends Omit<IndeRunCapacitorPluginContract, "checkCapabilities"> {
+    stream(request: TaskRequest): Promise<StreamRun>;
+    /** The plugin's `{ providers }` envelope, unwrapped to match the platform SDKs. */
+    checkCapabilities(): Promise<ProviderCapabilitySnapshot[]>;
+}
+export declare const IndeRunCapacitor: IndeRunCapacitorApi;
 export interface IndeRunCapacitorInstance {
     run(request: TaskRequest): Promise<TaskResult>;
+    stream(request: TaskRequest): Promise<StreamRun>;
+    checkCapabilities(): Promise<ProviderCapabilitySnapshot[]>;
 }
 export declare function createIndeRunCapacitor(options?: ConfigureOptions): IndeRunCapacitorInstance;
-export type { ConfigureOptions, IndeRunCapacitorPluginContract as IndeRunCapacitorPlugin, OpenAIProviderBootstrapOptions, TaskRequest, TaskResult };
+export { STREAM_ERROR_NAME, STREAM_EVENT_NAME } from "./streaming.js";
+export type { CancelStreamOptions, CheckCapabilitiesResult, ConfigureOptions, IndeRunCapacitorPluginContract as IndeRunCapacitorPlugin, OnnxProviderBootstrapOptions, OpenAIProviderBootstrapOptions, ProviderCapabilitySnapshot, ProviderDescriptor, ProviderDynamicCapabilities, StartStreamOptions, StreamErrorNotification, StreamEventNotification, StreamRun, SystemModelProviderBootstrapOptions, TaskRequest, TaskResult };
 export type * from "@independo/inderun-contracts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,IAAI,8BAA8B,EACxD,8BAA8B,EAC/B,MAAM,kBAAkB,CAAC;AAuB1B,eAAO,MAAM,gBAAgB,EAAE,8BAgB9B,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAChD;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,wBAAwB,CAiB3F;AAED,YAAY,EACV,gBAAgB,EAChB,8BAA8B,IAAI,sBAAsB,EACxD,8BAA8B,EAC9B,WAAW,EACX,UAAU,EACX,CAAC;AAEF,mBAAmB,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE7F,OAAO,KAAK,EACV,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,sBAAsB,IAAI,8BAA8B,EACxD,4BAA4B,EAC5B,8BAA8B,EAC9B,0BAA0B,EAC1B,kBAAkB,EAClB,2BAA2B,EAC3B,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,SAAS,EACT,mCAAmC,EACpC,MAAM,kBAAkB,CAAC;AAQ1B;;;;GAIG;AACH,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,8BAA8B,EAAE,mBAAmB,CAAC;IACpG,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACjD,mFAAmF;IACnF,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAC;CAC5D;AAED,eAAO,MAAM,gBAAgB,EAAE,mBAqD9B,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/C,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACjD,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAC;CAC5D;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,wBAAwB,CA4B3F;AAED,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEtE,YAAY,EACV,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,8BAA8B,IAAI,sBAAsB,EACxD,4BAA4B,EAC5B,8BAA8B,EAC9B,0BAA0B,EAC1B,kBAAkB,EAClB,2BAA2B,EAC3B,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,SAAS,EACT,mCAAmC,EACnC,WAAW,EACX,UAAU,EACX,CAAC;AAEF,mBAAmB,8BAA8B,CAAC"}

package/dist/index.js

@@ -1,20 +1,9 @@
-import { validateIndeRunError } from "@independo/inderun-contracts";
 import { registerPlugin } from "@capacitor/core";
+import { normalizePluginError } from "./errors.js";
+import { startCapacitorStream } from "./streaming.js";
 const IndeRunCapacitorNative = registerPlugin("IndeRunCapacitor", {
     web: () => import("./web.js").then((module) => new module.IndeRunWeb())
 });
-function normalizePluginError(error) {
-    if (validateIndeRunError(error)) {
-        return error;
-    }
-    if (typeof error === "object" &&
-        error !== null &&
-        "data" in error &&
-        validateIndeRunError(error.data)) {
-        return error.data;
-    }
-    return error;
-}
 export const IndeRunCapacitor = {
     async configure(options) {
         try {
@@ -31,6 +20,38 @@ export const IndeRunCapacitor = {
         catch (error) {
             throw normalizePluginError(error);
         }
+    },
+    async checkCapabilities() {
+        try {
+            const result = await IndeRunCapacitorNative.checkCapabilities();
+            return result.providers;
+        }
+        catch (error) {
+            throw normalizePluginError(error);
+        }
+    },
+    async startStream(options) {
+        try {
+            return await IndeRunCapacitorNative.startStream(options);
+        }
+        catch (error) {
+            throw normalizePluginError(error);
+        }
+    },
+    async cancelStream(options) {
+        try {
+            await IndeRunCapacitorNative.cancelStream(options);
+        }
+        catch (error) {
+            throw normalizePluginError(error);
+        }
+    },
+    addListener: IndeRunCapacitorNative.addListener.bind(IndeRunCapacitorNative),
+    async removeAllListeners() {
+        await IndeRunCapacitorNative.removeAllListeners();
+    },
+    stream(request) {
+        return startCapacitorStream(IndeRunCapacitorNative, request);
     }
 };
 export function createIndeRunCapacitor(options) {
@@ -46,6 +67,16 @@ export function createIndeRunCapacitor(options) {
         async run(request) {
             await ensureConfigured();
             return IndeRunCapacitor.run(request);
+        },
+        async stream(request) {
+            await ensureConfigured();
+            return IndeRunCapacitor.stream(request);
+        },
+        // Configures first: without a registry there are no providers to report on.
+        async checkCapabilities() {
+            await ensureConfigured();
+            return IndeRunCapacitor.checkCapabilities();
         }
     };
 }
+export { STREAM_ERROR_NAME, STREAM_EVENT_NAME } from "./streaming.js";

package/dist/streaming.d.ts

@@ -0,0 +1,17 @@
+import { type TaskRequest } from "@independo/inderun-contracts";
+import type { IndeRunCapacitorPlugin, StreamRun } from "./definitions.js";
+/**
+ * Listener event names. These are **public contract**: an app may attach its own
+ * listener, and native code emits exactly these. Renaming one is a breaking change.
+ */
+export declare const STREAM_EVENT_NAME = "indeRunStreamEvent";
+export declare const STREAM_ERROR_NAME = "indeRunStreamError";
+/**
+ * Starts a Mode 2 run over the bridge and reassembles it into the same `StreamRun`
+ * shape `@independo/inderun-web` returns directly.
+ *
+ * The listeners are registered *before* `startStream` is called, so no event can be
+ * emitted for a run whose sink does not exist yet.
+ */
+export declare function startCapacitorStream(plugin: IndeRunCapacitorPlugin, request: TaskRequest): Promise<StreamRun>;
+//# sourceMappingURL=streaming.d.ts.map

package/dist/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../src/streaming.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EACV,sBAAsB,EAGtB,SAAS,EACV,MAAM,kBAAkB,CAAC;AAG1B;;;GAGG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AACtD,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AA6QtD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,SAAS,CAAC,CAwDpB"}

package/dist/streaming.js

@@ -0,0 +1,303 @@
+import { validateStreamRunHandle } from "@independo/inderun-contracts";
+import { createBridgeError, normalizePluginError } from "./errors.js";
+/**
+ * Listener event names. These are **public contract**: an app may attach its own
+ * listener, and native code emits exactly these. Renaming one is a breaking change.
+ */
+export const STREAM_EVENT_NAME = "indeRunStreamEvent";
+export const STREAM_ERROR_NAME = "indeRunStreamError";
+/**
+ * How long to wait, after the terminal event has arrived, for a still-missing
+ * earlier event before declaring the run's event sequence irrecoverable.
+ *
+ * Deliberately a module constant rather than a public option: any value here is a
+ * behavioural policy, and behaviour belongs in the engines, not in the bridge.
+ */
+const REORDER_GRACE_MS = 250;
+function createStreamId() {
+    const globalCrypto = globalThis.crypto;
+    if (typeof globalCrypto?.randomUUID === "function") {
+        return globalCrypto.randomUUID();
+    }
+    return `stream_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 11)}`;
+}
+/**
+ * Reassembles one run's canonical event sequence on the JS side of the bridge.
+ *
+ * The bridge hop is not order-preserving, which is why `StreamEvent.sequence` is
+ * the contract's ordering authority rather than arrival order. This sink buffers
+ * out-of-order arrivals and yields strictly by `sequence`, so a consumer sees
+ * exactly what the engine's Event Gate admitted, in the order it admitted it.
+ *
+ * It owns no run semantics: it never synthesizes a terminal event, never retries,
+ * never decides an outcome. A gap that never closes becomes a transport error, not
+ * an invented ending. Everything about *what* a run does stays in the engines.
+ */
+class StreamSink {
+    nextSequence = 0;
+    pending = new Map();
+    ready = [];
+    terminalSequence = null;
+    runId = null;
+    failure = null;
+    done = false;
+    wake = null;
+    graceTimer = null;
+    bindRunId(runId) {
+        this.runId = runId;
+    }
+    /**
+     * True once the run has ended — the terminal event has been admitted, or the
+     * transport has failed — regardless of whether the consumer has drained it yet.
+     */
+    isFinished() {
+        return this.done || this.failure !== null;
+    }
+    accept(event) {
+        if (this.isFinished()) {
+            return;
+        }
+        // Defence in depth on top of streamId routing: an event for another run is
+        // never this run's business.
+        if (this.runId !== null && event.runId !== this.runId) {
+            return;
+        }
+        // Already delivered (a duplicate), or arriving after the terminal that closed
+        // the run. The Event Gate guarantees the terminal is the highest sequence.
+        if (event.sequence < this.nextSequence) {
+            return;
+        }
+        if (this.terminalSequence !== null && event.sequence > this.terminalSequence) {
+            return;
+        }
+        this.pending.set(event.sequence, event);
+        if (event.type === "terminal") {
+            this.terminalSequence = event.sequence;
+        }
+        this.drain();
+    }
+    fail(error) {
+        if (this.isFinished()) {
+            return;
+        }
+        this.clearGrace();
+        this.failure = error;
+        this.signal();
+    }
+    async *iterate() {
+        for (;;) {
+            while (this.ready.length > 0) {
+                yield this.ready.shift();
+            }
+            if (this.failure !== null) {
+                throw this.failure;
+            }
+            if (this.done) {
+                return;
+            }
+            await new Promise((resolve) => {
+                this.wake = resolve;
+            });
+        }
+    }
+    dispose() {
+        this.clearGrace();
+    }
+    drain() {
+        let moved = false;
+        for (;;) {
+            const next = this.pending.get(this.nextSequence);
+            if (next === undefined) {
+                break;
+            }
+            this.pending.delete(this.nextSequence);
+            this.ready.push(next);
+            this.nextSequence += 1;
+            moved = true;
+        }
+        if (this.terminalSequence !== null) {
+            if (this.nextSequence > this.terminalSequence) {
+                // The whole 0..terminal range has been handed over, in order.
+                this.clearGrace();
+                this.done = true;
+            }
+            else {
+                this.startGrace();
+            }
+        }
+        if (moved || this.done) {
+            this.signal();
+        }
+    }
+    startGrace() {
+        if (this.graceTimer !== null) {
+            return;
+        }
+        this.graceTimer = setTimeout(() => {
+            this.graceTimer = null;
+            this.onGraceExpired();
+        }, REORDER_GRACE_MS);
+    }
+    clearGrace() {
+        if (this.graceTimer !== null) {
+            clearTimeout(this.graceTimer);
+            this.graceTimer = null;
+        }
+    }
+    /**
+     * The terminal arrived but an earlier event never did.
+     *
+     * Hand over the content that did arrive, in order, then fail. The terminal itself
+     * is deliberately withheld: delivering it would assert an ending — a `finalText`,
+     * a clean `completed` — that the consumer's own event sequence does not support.
+     * A transport that lost events reports that, rather than papering over it.
+     */
+    onGraceExpired() {
+        if (this.isFinished()) {
+            return;
+        }
+        const terminalSequence = this.terminalSequence;
+        let lost = 0;
+        for (let sequence = this.nextSequence; sequence <= terminalSequence; sequence += 1) {
+            if (!this.pending.has(sequence)) {
+                lost += 1;
+            }
+        }
+        for (const [sequence, event] of [...this.pending.entries()].sort(([a], [b]) => a - b)) {
+            if (sequence !== terminalSequence) {
+                this.ready.push(event);
+            }
+        }
+        this.pending.clear();
+        this.failure = createBridgeError(`Capacitor bridge lost ${lost} stream event(s) for run ${this.runId ?? "<unknown>"}.`, this.runId ?? undefined);
+        this.signal();
+    }
+    signal() {
+        const wake = this.wake;
+        this.wake = null;
+        wake?.();
+    }
+}
+/**
+ * Owns the two plugin listeners and fans notifications out to the sink for each
+ * live run.
+ *
+ * One registration serves every concurrent run: listeners are attached on the
+ * first bind and removed once the last run releases, so a consumer that streams
+ * repeatedly does not accumulate listeners.
+ */
+class StreamDispatcher {
+    sinks = new Map();
+    handles = null;
+    registering = null;
+    async bind(plugin, streamId, sink) {
+        this.sinks.set(streamId, sink);
+        try {
+            await this.ensureListeners(plugin);
+        }
+        catch (error) {
+            this.sinks.delete(streamId);
+            throw error;
+        }
+    }
+    release(streamId) {
+        const sink = this.sinks.get(streamId);
+        if (sink === undefined) {
+            return;
+        }
+        sink.dispose();
+        this.sinks.delete(streamId);
+        if (this.sinks.size === 0) {
+            void this.removeListeners();
+        }
+    }
+    ensureListeners(plugin) {
+        this.registering ??= (async () => {
+            const [events, errors] = await Promise.all([
+                plugin.addListener(STREAM_EVENT_NAME, this.handleEvent),
+                plugin.addListener(STREAM_ERROR_NAME, this.handleError)
+            ]);
+            this.handles = [events, errors];
+        })().catch((error) => {
+            this.registering = null;
+            throw error;
+        });
+        return this.registering;
+    }
+    async removeListeners() {
+        const handles = this.handles;
+        this.handles = null;
+        this.registering = null;
+        if (handles === null) {
+            return;
+        }
+        await Promise.all(handles.map((handle) => handle.remove()));
+    }
+    // Arrow properties: they are handed to addListener and must keep their binding.
+    handleEvent = (notification) => {
+        // An unknown streamId is a retained notification replayed for a run that has
+        // already finished. Dropping it is correct, not an error.
+        this.sinks.get(notification.streamId)?.accept(notification.event);
+    };
+    handleError = (notification) => {
+        this.sinks.get(notification.streamId)?.fail(notification.error);
+    };
+}
+const dispatcher = new StreamDispatcher();
+/**
+ * Starts a Mode 2 run over the bridge and reassembles it into the same `StreamRun`
+ * shape `@independo/inderun-web` returns directly.
+ *
+ * The listeners are registered *before* `startStream` is called, so no event can be
+ * emitted for a run whose sink does not exist yet.
+ */
+export async function startCapacitorStream(plugin, request) {
+    const streamId = createStreamId();
+    const sink = new StreamSink();
+    await dispatcher.bind(plugin, streamId, sink);
+    let handle;
+    try {
+        handle = await plugin.startStream({ streamId, request });
+    }
+    catch (error) {
+        dispatcher.release(streamId);
+        throw normalizePluginError(error);
+    }
+    if (!validateStreamRunHandle(handle)) {
+        dispatcher.release(streamId);
+        throw createBridgeError("Capacitor bridge received a malformed StreamRunHandle from the native plugin.");
+    }
+    sink.bindRunId(handle.runId);
+    let cancelled = false;
+    const requestCancel = (reason) => {
+        // Cancelling a run that has already ended is a no-op by contract, and is
+        // answered locally so the bridge is not crossed for nothing.
+        if (cancelled || sink.isFinished()) {
+            return;
+        }
+        cancelled = true;
+        void plugin
+            .cancelStream({ streamId, ...(reason !== undefined ? { reason } : {}) })
+            .catch((error) => sink.fail(normalizePluginError(error)));
+    };
+    const generator = (async function* consume() {
+        try {
+            yield* sink.iterate();
+        }
+        finally {
+            // Covers the consumer abandoning the loop with `break`: tell native to stop
+            // producing, and let go of the listeners.
+            requestCancel();
+            dispatcher.release(streamId);
+        }
+    })();
+    return {
+        handle,
+        events: {
+            // Single-use, matching the engines: the run is driven once, not restarted per
+            // consumer, so a second iteration observes completion rather than a replay.
+            [Symbol.asyncIterator]: () => generator
+        },
+        cancel: requestCancel
+    };
+}

package/dist/web.d.ts

@@ -1,10 +1,26 @@
-import type { TaskResult } from "@independo/inderun-contracts";
+import type { StreamRunHandle, TaskResult } from "@independo/inderun-contracts";
 import { WebPlugin } from "@capacitor/core";
-import type { ConfigureOptions, IndeRunCapacitorPlugin } from "./definitions.js";
+import type { CancelStreamOptions, CheckCapabilitiesResult, ConfigureOptions, IndeRunCapacitorPlugin, StartStreamOptions } from "./definitions.js";
 import type { TaskRequest } from "@independo/inderun-contracts";
 export declare class IndeRunWeb extends WebPlugin implements IndeRunCapacitorPlugin {
     private engine;
+    private readonly activeStreams;
+    private readonly startingStreams;
+    private readonly pendingCancels;
     configure(options?: ConfigureOptions): Promise<void>;
     run(request: TaskRequest): Promise<TaskResult>;
+    checkCapabilities(): Promise<CheckCapabilitiesResult>;
+    /**
+     * The web path deliberately round-trips through `notifyListeners` rather than
+     * handing the engine's `StreamRun` straight back.
+     *
+     * Short-circuiting would require the facade to branch on the platform and would
+     * leave two reassembly paths whose equivalence is only a convention — while this
+     * way there is exactly one, exercised on every platform. It also equalizes the
+     * loss of generator backpressure that the native paths have regardless.
+     */
+    startStream(options: StartStreamOptions): Promise<StreamRunHandle>;
+    cancelStream(options: CancelStreamOptions): Promise<void>;
+    private pump;
 }
 //# sourceMappingURL=web.d.ts.map

package/dist/web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAGhE,qBAAa,UAAW,SAAQ,SAAU,YAAW,sBAAsB;IACzE,OAAO,CAAC,MAAM,CAAwB;IAEhC,SAAS,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BzD;IAEK,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAYnD;CACF"}
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EACV,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAEnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAIhE,qBAAa,UAAW,SAAQ,SAAU,YAAW,sBAAsB;IACzE,OAAO,CAAC,MAAM,CAAwB;IAItC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgC;IAC9D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqB;IACrD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyC;IAElE,SAAS,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCzD;IAEK,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAYnD;IAEK,iBAAiB,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAe1D;IAED;;;;;;;;OAQG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC,CA8BvE;IAEK,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiB9D;YAEa,IAAI;CAenB"}