lanka 1.0.1 → 1.1.0

package/dist/stream/index.d.ts

@@ -0,0 +1,386 @@
+import { c as ILankaPlugin } from '../createLanka-DI1CSy2Q.js';
+import '../createLankaScope-BiFxNQgl.js';
+import '../LankaSharedStoreLocator-zS2kLu-S.js';
+import '../ALankaSharedStore-B7uepuuk.js';
+import 'zustand/vanilla';
+import '../activeRuntime-B336NU5I.js';
+import '../ILankaScenarioVM-DUsI-fSc.js';
+import '../LankaScenarioLocator-D86TIwiu.js';
+import '../ILankaScenarioMetadata-GoWWNEQL.js';
+import '../ALankaGateway-CkW1LbKE.js';
+import '../lankaStandardValidator-CL-r-zEV.js';
+import '@standard-schema/spec';
+import '../ILankaRuntimeConfig-Vl436GWK.js';
+import '../lankaHttpInFlight-Bk1eIuSx.js';
+import '../lankaRequestMiddleware-DAC5kCb7.js';
+
+/**
+ * What a subscriber is handed when a named event arrives.
+ *
+ * A record rather than a generic: the transport parsed bytes and knows nothing
+ * about what they mean, and a bridge is the layer that names the shape. Typing
+ * it here would be the transport asserting something it did not check.
+ */
+type TLankaStreamEventCallback = (payload: Record<string, unknown>) => void;
+
+/**
+ * Called after a connection is re-established, never on the first one.
+ *
+ * No arguments deliberately: the one fact it carries is "there is a gap in what
+ * you were told", and nothing about the gap is knowable from this side.
+ */
+type TLankaStreamReconnectCallback = () => void;
+
+/**
+ * A connection that pushes named events, whatever carries them.
+ *
+ * The port is the whole reason a screen can stop caring which protocol it is
+ * on. `text/event-stream`, a WebSocket, a `graphql-ws` subscription and a gRPC
+ * server stream differ in how bytes arrive and in nothing a bridge can see —
+ * and the choice between them is made by a proxy, a load balancer or a backend
+ * team, none of which the application controls.
+ *
+ * What a bridge needs is exactly this: subscribe to a named event, learn that
+ * the connection came back, and be told whether there is a connection to be had
+ * at all. Everything else — reconnect backoff, envelope parsing, credentials,
+ * a handshake — is an implementation's own business, and `ALankaStreamTransport`
+ * is where the parts that are the same for all of them live.
+ *
+ * ## Kept minimal on purpose
+ *
+ * A CONSUMER implements this — a native bridge, a mock, a socket the
+ * application already had — so every member added later is a compile error in
+ * code nobody touched (`skills/surface/SKILL.md` §6b). Five members is not
+ * meanness; it is the only form the promise survives in.
+ */
+interface ILankaServerEventTransport {
+    /** Whether this engine can carry server events at all. */
+    isSupported: () => boolean;
+    connect: () => void;
+    disconnect: () => void;
+    /** Subscribes to one named event. Returns the unsubscribe. */
+    on: (eventType: string, callback: TLankaStreamEventCallback) => () => void;
+    /**
+     * Called after a connection is re-established, never on the first one.
+     *
+     * What it is for: everything that happened while the connection was down was
+     * missed, so a screen refetches rather than assuming it is current.
+     */
+    onReconnect: (callback: TLankaStreamReconnectCallback) => () => void;
+}
+
+interface ILankaStreamTriggerContext {
+    /** Whether a SERVER event handler is running right now. */
+    isActive: () => boolean;
+    /** Runs a function marked as triggered by a server event. */
+    run: <T>(fn: () => T) => T;
+}
+/**
+ * The "this change came from outside" marker.
+ *
+ * A handler that updates state cannot tell its own change from someone else's:
+ * the user pressed a button and then receives the server event about that
+ * button. Without the marker the screen notifies the user about their own
+ * action, and an optimistic update is rolled back by a "foreign" response that
+ * in fact confirms it.
+ *
+ * ## An instance, not a module variable
+ *
+ * A module-level flag is one per process: two framework instances (a test beside
+ * the app) would share it, and one instance's handler would see a marker set by
+ * the other.
+ *
+ * ## Boundaries
+ *
+ * The marker is SYNCHRONOUS: it holds for the duration of the call and is
+ * cleared in `finally`. An async continuation (an `await` inside the handler)
+ * no longer sees it — honestly so: after an `await` control has been anywhere,
+ * and claiming "we are still inside a server event" would be untrue.
+ */
+declare const createLankaStreamTriggerContext: () => ILankaStreamTriggerContext;
+
+/**
+ * A server-event -> application-scenario bridge.
+ *
+ * It KNOWS about the event stream and the "came from outside" marker, and knows
+ * no concrete event type: which bridges exist is the application's domain.
+ *
+ * ## Inbound only, even where the wire is two-way
+ *
+ * A WebSocket can send and a bridge cannot, deliberately. A bridge translates
+ * what arrived into a fact the rest of the application already understands, and
+ * a bridge that also sends becomes the one object that both starts and finishes
+ * a conversation — untestable without a socket, and the place every screen
+ * eventually reaches into. Sending belongs to whatever already owns the action:
+ * a gateway holding the channel, or a ViewModel calling it.
+ *
+ * ## Why subscriptions are collected rather than forgotten
+ *
+ * A bridge that subscribes in its constructor and never unsubscribes cannot
+ * notice the problem while it lives exactly as long as the application. In a
+ * package it is different — the plugin is removed, the instance is disposed, a
+ * dev server reloads the module — and a leftover subscription keeps triggering a
+ * dead instance's scenarios.
+ */
+declare abstract class ALankaStreamBridge {
+    private readonly unsubscribes;
+    protected readonly stream: ILankaServerEventTransport;
+    protected readonly trigger: ILankaStreamTriggerContext;
+    constructor(stream: ILankaServerEventTransport, trigger: ILankaStreamTriggerContext);
+    /** Subscribes the bridge to its events. Called by the plugin on install. */
+    abstract register(): void;
+    /** Removes everything the bridge subscribed to. */
+    dispose(): void;
+    /**
+     * Subscribes to an event type; the handler runs with the "from outside"
+     * marker.
+     *
+     * The marker is set HERE rather than left to each bridge: a handler that
+     * forgot it is indistinguishable from a user action, and the difference is
+     * silent — the screen simply behaves oddly in a rare case.
+     */
+    protected on(eventType: string, handler: TLankaStreamEventCallback): void;
+    /** The same for an event with no payload. */
+    protected onSignal(eventType: string, handler: () => void): void;
+    /** Catch-up for what was missed while disconnected. */
+    protected onReconnect(handler: () => void): void;
+}
+
+/** What the bridges factory is handed: the connection, and the marker. */
+interface ILankaStreamPluginContext {
+    stream: ILankaServerEventTransport;
+    trigger: ILankaStreamTriggerContext;
+}
+interface ILankaStreamPluginConfig {
+    /** The connection this plugin owns for its lifetime. */
+    transport: ILankaServerEventTransport;
+    /**
+     * The application's bridges, created by it — the framework knows no event type.
+     *
+     * A factory rather than ready objects: a bridge needs the transport and the
+     * "from outside" marker, and both belong to THIS plugin installation. The same
+     * bridge declaration can therefore be handed to two instances in one process.
+     */
+    bridges?: (context: ILankaStreamPluginContext) => readonly ALankaStreamBridge[];
+    /**
+     * Connect as soon as the plugin is registered. Off by default.
+     *
+     * Deliberately off: the stream is opened for an AUTHENTICATED user, and when
+     * that happens is the application's knowledge. A plugin that connected by
+     * itself would open a connection on the sign-in screen.
+     */
+    connectOnInstall?: boolean;
+    /**
+     * The name the plugin is registered under. Defaults to `lanka/stream`.
+     *
+     * A protocol package passes its own npm name, so a duplicate registration
+     * names the package a reader can go and look at. Registering twice is refused
+     * by the registry, and two copies of one connection is exactly the mistake
+     * worth refusing.
+     */
+    name?: string;
+}
+interface ILankaStreamPlugin extends ILankaPlugin {
+    /** The connection: subscribe, connect, disconnect. */
+    readonly stream: ILankaServerEventTransport;
+    /** The "this change came from the server" marker. */
+    readonly trigger: ILankaStreamTriggerContext;
+}
+/**
+ * A pushing connection wired into the framework's lifetime.
+ *
+ * Usable directly — hand it any `ILankaServerEventTransport` and your bridges —
+ * and it is also what every protocol plugin in this repository is built on, so
+ * the four of them cannot disagree about installation order.
+ *
+ * ## The order in teardown is the whole point
+ *
+ * Bridges are detached BEFORE the connection is closed. The other order leaves
+ * them a window in which a dying connection delivers one last event into
+ * scenarios belonging to an instance that is being disposed.
+ */
+declare const lankaStream: (config: ILankaStreamPluginConfig) => ILankaStreamPlugin;
+
+/** What every pushing connection is configured with, whatever carries it. */
+interface ILankaStreamConfig {
+    /** How many reconnect attempts before giving up. Defaults to 10. */
+    maxReconnectAttempts?: number;
+    /** The first pause between attempts; it doubles from there. Defaults to 1s. */
+    reconnectDelayMs?: number;
+    /** Ceiling on the pause between attempts. Defaults to 30 seconds. */
+    maxReconnectDelayMs?: number;
+    /**
+     * Refreshes authorization when attempts are exhausted. `true` means try again.
+     *
+     * A function, not a URL: a framework that knew the endpoint would also know
+     * the response shape and how the session is stored.
+     */
+    refreshAuth?: () => Promise<boolean>;
+    /** The session is lost for good: the application signs the user out. */
+    onSessionLost?: () => void;
+}
+/**
+ * How a subclass reports what happened on the wire.
+ *
+ * Three facts and no more, because they are the three the ladder above branches
+ * on. A subclass able to reach further into the base could reset the attempt
+ * counter or fire a reconnect by hand, which is exactly the state this class
+ * exists to own.
+ */
+interface ILankaStreamTransportHandlers {
+    /**
+     * The connection is up and ready to carry subscriptions.
+     *
+     * Called by the subclass when the far end is actually usable — after a
+     * handshake, not merely after a socket opened — because the base answers it by
+     * subscribing to every event type somebody is waiting for.
+     */
+    opened: () => void;
+    /** A named event arrived. */
+    received: (eventType: string, payload: Record<string, unknown>) => void;
+    /** The connection is gone: dropped, refused, or closed by the far end. */
+    lost: () => void;
+}
+/**
+ * The half of a pushing connection that is the same for every protocol.
+ *
+ * Four transports in this repository — server-sent events, a WebSocket, a
+ * `graphql-ws` subscription and a gRPC server stream — differ in how a
+ * connection is opened and in how bytes become a named event. They do not
+ * differ in anything below:
+ *
+ * - who is listening to which event type, and dispatch to a COPY of that set;
+ * - the reconnect ladder: growing backoff with a ceiling, an attempt count that
+ *   only resets on a connection that actually opened, one auth refresh at the
+ *   end of it, and an explicit disconnect that outranks everything scheduled;
+ * - `onReconnect` meaning "you missed something", so it never fires the first
+ *   time.
+ *
+ * A subclass writes `open` and `close`, and `subscribeTo` / `unsubscribeFrom`
+ * when the wire has to be told which events are wanted.
+ *
+ * ## A subclass never says "connected"
+ *
+ * Everything the ladder decides is decided here, off the three handlers. That is
+ * what keeps a protocol package free of the bug this shape is prone to:
+ * resetting the attempt counter where reconnection STARTS rather than where it
+ * SUCCEEDS, after which a ten-attempt ceiling exists, reads as a guard, and can
+ * never fire.
+ */
+declare abstract class ALankaStreamTransport implements ILankaServerEventTransport {
+    private readonly listeners;
+    private readonly reconnectCallbacks;
+    private readonly config;
+    private readonly handlers;
+    private reconnectTimer;
+    private reconnectAttempts;
+    /** A connection exists as far as this class is concerned. */
+    private live;
+    /**
+     * A connection has opened at least once.
+     *
+     * Separate from `hadError`, and both are needed. A first attempt that FAILS
+     * and a second that succeeds is not a reconnection — nothing was ever
+     * delivered, so nothing was missed — and announcing one there makes every
+     * screen refetch the data it has just loaded.
+     */
+    private everConnected;
+    /** The last connection ended badly, so the next `opened` is a RE-connection. */
+    private hadError;
+    /** Disconnected EXPLICITLY: everything scheduled after this must die. */
+    private stopped;
+    constructor(config?: ILankaStreamConfig);
+    /**
+     * Whether this engine can carry the connection at all.
+     *
+     * `true` unless a subclass says otherwise, because most transports need
+     * nothing the platform might be missing. Where one does, the answer is a
+     * `typeof` guard: an engine without the global gets the plugin switched off
+     * for the session rather than a `ReferenceError` from inside the framework.
+     */
+    isSupported(): boolean;
+    connect(): void;
+    disconnect(): void;
+    /** Subscribes to an event type. Returns an unsubscribe function. */
+    on(eventType: string, callback: TLankaStreamEventCallback): () => void;
+    /** Notification after EVERY reconnection. Returns an unsubscribe function. */
+    onReconnect(callback: TLankaStreamReconnectCallback): () => void;
+    /**
+     * Opens the connection and reports through the handlers.
+     *
+     * Called once per attempt. Throwing is allowed and means "this engine cannot
+     * do it": the transport goes quiet instead of retrying.
+     */
+    protected abstract open(handlers: ILankaStreamTransportHandlers): void;
+    /**
+     * Closes whatever `open` opened.
+     *
+     * Called at most ONCE per connection, and never for one `open` did not finish
+     * — so a subclass may assume it holds what it created. The base owns that
+     * guarantee (see `acceptLoss`) precisely so a subclass does not carry a flag
+     * to make it true.
+     */
+    protected abstract close(): void;
+    /**
+     * Tells the wire that an event type is wanted, where the wire needs telling.
+     *
+     * Called for every already-known type as soon as a connection opens, and for
+     * each new one after that — so a subclass never has to remember what was
+     * subscribed before the link came back.
+     */
+    protected subscribeTo(eventType: string): void;
+    /** The reverse, when the last subscriber of a type goes away. */
+    protected unsubscribeFrom(eventType: string): void;
+    /** Every event type somebody is waiting for right now. */
+    protected subscribedEventTypes(): readonly string[];
+    private acceptOpen;
+    private acceptLoss;
+    private forget;
+    private dispatch;
+    private clearReconnect;
+    private scheduleReconnect;
+    /**
+     * The attempts are spent: refresh the session once, or report it lost.
+     *
+     * `stopped` is re-read after the await. The refresh is a network call of
+     * unknown length, and an application that signed the user out while it was in
+     * flight must not be handed a connection afterwards.
+     */
+    private lastResort;
+}
+
+/**
+ * A bridge's protected surface, handed to whoever writes one by calling.
+ *
+ * The names match `ALankaStreamBridge`'s protected members exactly: a consumer
+ * who switches styles moves `this.on(...)` to `on(...)` and changes nothing
+ * else. Checked by `scripts/check-parity.mjs`.
+ */
+interface ILankaStreamBridgeContext {
+    /** Subscribes to an event type; the handler runs with the "from outside" marker. */
+    on: (eventType: string, handler: TLankaStreamEventCallback) => void;
+    /** The same for an event with no payload. */
+    onSignal: (eventType: string, handler: () => void) => void;
+    /** Catch-up for what was missed while disconnected. */
+    onReconnect: (handler: () => void) => void;
+}
+
+/**
+ * A bridge, without writing a class.
+ *
+ * What a bridge does is one function — subscribe these events, trigger those
+ * scenarios — and the class exists to carry the subscriptions and the "from
+ * outside" marker, which this carries identically: it IS an `ALankaStreamBridge`.
+ *
+ * The plugin receives what a class-style bridge would give it, `dispose`
+ * included, so nothing above knows which style wrote it.
+ *
+ * Two steps rather than one call: a bridge needs the transport and the marker,
+ * and both belong to the plugin INSTALLATION rather than to the module that
+ * declares the bridge. So the declaration is written once at module level and
+ * the plugin applies it, which is what lets the same bridge be handed to two
+ * instances in one process.
+ */
+declare const createLankaStreamBridge: (register: (context: ILankaStreamBridgeContext) => void) => (stream: ILankaServerEventTransport, trigger: ILankaStreamTriggerContext) => ALankaStreamBridge;
+
+export { ALankaStreamBridge, ALankaStreamTransport, type ILankaServerEventTransport, type ILankaStreamBridgeContext, type ILankaStreamConfig, type ILankaStreamPlugin, type ILankaStreamPluginConfig, type ILankaStreamPluginContext, type ILankaStreamTransportHandlers, type ILankaStreamTriggerContext, type TLankaStreamEventCallback, type TLankaStreamReconnectCallback, createLankaStreamBridge, createLankaStreamTriggerContext, lankaStream };

package/dist/stream/index.js

@@ -0,0 +1,287 @@
+// src/stream/_factories/create-lanka-stream-trigger-context/createLankaStreamTriggerContext.ts
+var createLankaStreamTriggerContext = () => {
+  let active = false;
+  return {
+    isActive: () => active,
+    run(fn) {
+      const previous = active;
+      active = true;
+      try {
+        return fn();
+      } finally {
+        active = previous;
+      }
+    }
+  };
+};
+
+// src/stream/lanka-stream/lankaStream.ts
+var lankaStream = (config) => {
+  const stream = config.transport;
+  const trigger = createLankaStreamTriggerContext();
+  return {
+    name: config.name ?? "lanka/stream",
+    stream,
+    trigger,
+    install() {
+      const bridges = config.bridges?.({ stream, trigger }) ?? [];
+      for (const bridge of bridges) bridge.register();
+      if (config.connectOnInstall) stream.connect();
+      return () => {
+        for (const bridge of bridges) bridge.dispose();
+        stream.disconnect();
+      };
+    }
+  };
+};
+
+// src/stream/_abstractions/lanka-stream-transport/ALankaStreamTransport.ts
+var ALankaStreamTransport = class {
+  listeners = /* @__PURE__ */ new Map();
+  reconnectCallbacks = /* @__PURE__ */ new Set();
+  config;
+  handlers;
+  reconnectTimer = null;
+  reconnectAttempts = 0;
+  /** A connection exists as far as this class is concerned. */
+  live = false;
+  /**
+   * A connection has opened at least once.
+   *
+   * Separate from `hadError`, and both are needed. A first attempt that FAILS
+   * and a second that succeeds is not a reconnection — nothing was ever
+   * delivered, so nothing was missed — and announcing one there makes every
+   * screen refetch the data it has just loaded.
+   */
+  everConnected = false;
+  /** The last connection ended badly, so the next `opened` is a RE-connection. */
+  hadError = false;
+  /** Disconnected EXPLICITLY: everything scheduled after this must die. */
+  stopped = false;
+  constructor(config = {}) {
+    this.config = config;
+    this.handlers = {
+      opened: () => {
+        this.acceptOpen();
+      },
+      received: (eventType, payload) => {
+        this.dispatch(eventType, payload);
+      },
+      lost: () => {
+        this.acceptLoss();
+      }
+    };
+  }
+  /**
+   * Whether this engine can carry the connection at all.
+   *
+   * `true` unless a subclass says otherwise, because most transports need
+   * nothing the platform might be missing. Where one does, the answer is a
+   * `typeof` guard: an engine without the global gets the plugin switched off
+   * for the session rather than a `ReferenceError` from inside the framework.
+   */
+  isSupported() {
+    return true;
+  }
+  connect() {
+    if (this.live) return;
+    if (!this.isSupported()) return;
+    this.stopped = false;
+    this.live = true;
+    try {
+      this.open(this.handlers);
+    } catch {
+      this.live = false;
+    }
+  }
+  disconnect() {
+    this.stopped = true;
+    this.clearReconnect();
+    if (!this.live) return;
+    this.live = false;
+    this.close();
+  }
+  /** Subscribes to an event type. Returns an unsubscribe function. */
+  on(eventType, callback) {
+    let callbacks = this.listeners.get(eventType);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.listeners.set(eventType, callbacks);
+      if (this.live) this.subscribeTo(eventType);
+    }
+    callbacks.add(callback);
+    return () => {
+      this.forget(eventType, callback);
+    };
+  }
+  /** Notification after EVERY reconnection. Returns an unsubscribe function. */
+  onReconnect(callback) {
+    this.reconnectCallbacks.add(callback);
+    return () => {
+      this.reconnectCallbacks.delete(callback);
+    };
+  }
+  /**
+   * Tells the wire that an event type is wanted, where the wire needs telling.
+   *
+   * Called for every already-known type as soon as a connection opens, and for
+   * each new one after that — so a subclass never has to remember what was
+   * subscribed before the link came back.
+   */
+  subscribeTo(eventType) {
+    void eventType;
+  }
+  /** The reverse, when the last subscriber of a type goes away. */
+  unsubscribeFrom(eventType) {
+    void eventType;
+  }
+  /** Every event type somebody is waiting for right now. */
+  subscribedEventTypes() {
+    return [...this.listeners.keys()];
+  }
+  acceptOpen() {
+    for (const eventType of this.listeners.keys()) this.subscribeTo(eventType);
+    if (this.everConnected && this.hadError) {
+      for (const callback of [...this.reconnectCallbacks]) callback();
+    }
+    this.everConnected = true;
+    this.hadError = false;
+    this.reconnectAttempts = 0;
+  }
+  acceptLoss() {
+    if (!this.live) return;
+    this.hadError = true;
+    this.live = false;
+    this.close();
+    void this.scheduleReconnect();
+  }
+  forget(eventType, callback) {
+    const current = this.listeners.get(eventType);
+    if (!current) return;
+    current.delete(callback);
+    if (current.size > 0) return;
+    this.listeners.delete(eventType);
+    if (this.live) this.unsubscribeFrom(eventType);
+  }
+  dispatch(eventType, payload) {
+    const callbacks = this.listeners.get(eventType);
+    if (!callbacks) return;
+    for (const callback of [...callbacks]) callback(payload);
+  }
+  clearReconnect() {
+    if (!this.reconnectTimer) return;
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+  async scheduleReconnect() {
+    if (this.stopped) return;
+    if (this.reconnectAttempts >= (this.config.maxReconnectAttempts ?? 10)) {
+      await this.lastResort();
+      return;
+    }
+    const first = this.config.reconnectDelayMs ?? 1e3;
+    const delay = Math.min(
+      first * 2 ** this.reconnectAttempts,
+      this.config.maxReconnectDelayMs ?? 3e4
+    );
+    this.reconnectAttempts += 1;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.stopped) this.connect();
+    }, delay);
+  }
+  /**
+   * The attempts are spent: refresh the session once, or report it lost.
+   *
+   * `stopped` is re-read after the await. The refresh is a network call of
+   * unknown length, and an application that signed the user out while it was in
+   * flight must not be handed a connection afterwards.
+   */
+  async lastResort() {
+    const refreshed = await this.config.refreshAuth?.() ?? false;
+    if (this.stopped) return;
+    if (!refreshed) {
+      this.config.onSessionLost?.();
+      return;
+    }
+    this.reconnectAttempts = 0;
+    this.connect();
+  }
+};
+
+// src/stream/_abstractions/lanka-stream-bridge/ALankaStreamBridge.ts
+var ALankaStreamBridge = class {
+  unsubscribes = [];
+  stream;
+  trigger;
+  // Fields declared explicitly: `erasableSyntaxOnly` forbids parameter
+  // properties, the one TypeScript construct that emits code.
+  //
+  // The constructor is PUBLIC: the class is abstract and cannot be constructed
+  // on its own, while `protected` is inherited — and the application's subclass
+  // would then be unreachable to the code that creates it.
+  constructor(stream, trigger) {
+    this.stream = stream;
+    this.trigger = trigger;
+  }
+  /** Removes everything the bridge subscribed to. */
+  dispose() {
+    for (const unsubscribe of this.unsubscribes) unsubscribe();
+    this.unsubscribes.length = 0;
+  }
+  /**
+   * Subscribes to an event type; the handler runs with the "from outside"
+   * marker.
+   *
+   * The marker is set HERE rather than left to each bridge: a handler that
+   * forgot it is indistinguishable from a user action, and the difference is
+   * silent — the screen simply behaves oddly in a rare case.
+   */
+  on(eventType, handler) {
+    this.unsubscribes.push(
+      this.stream.on(eventType, (payload) => {
+        this.trigger.run(() => handler(payload));
+      })
+    );
+  }
+  /** The same for an event with no payload. */
+  onSignal(eventType, handler) {
+    this.on(eventType, () => handler());
+  }
+  /** Catch-up for what was missed while disconnected. */
+  onReconnect(handler) {
+    this.unsubscribes.push(
+      this.stream.onReconnect(() => {
+        this.trigger.run(handler);
+      })
+    );
+  }
+};
+
+// src/stream/_factories/create-lanka-stream-bridge/createLankaStreamBridge.ts
+var createLankaStreamBridge = (register) => (stream, trigger) => {
+  class FunctionalBridge extends ALankaStreamBridge {
+    register() {
+      register({
+        on: (eventType, handler) => {
+          this.on(eventType, handler);
+        },
+        onSignal: (eventType, handler) => {
+          this.onSignal(eventType, handler);
+        },
+        onReconnect: (handler) => {
+          this.onReconnect(handler);
+        }
+      });
+    }
+  }
+  return new FunctionalBridge(stream, trigger);
+};
+export {
+  ALankaStreamBridge,
+  ALankaStreamTransport,
+  createLankaStreamBridge,
+  createLankaStreamTriggerContext,
+  lankaStream
+};
+//# sourceMappingURL=index.js.map