lanka 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -1,16 +1,17 @@
-export { ALankaPlugin, ILankaBootstrapConfig, ILankaInstance, ILankaInstanceConfig, ILankaPlugin, ILankaScenarioBootstrapConfig, ILankaServiceConfig, ILankaStartOptions, TLankaStartConfig, createLanka, resetActiveLanka, startLanka } from './bootstrap/index.js';
+export { I as ILankaBootstrapConfig, a as ILankaInstance, b as ILankaInstanceConfig, c as ILankaPlugin, d as ILankaScenarioBootstrapConfig, e as ILankaServiceConfig, f as createLanka } from './createLanka-DI1CSy2Q.js';
+export { ALankaPlugin, ILankaStartOptions, TLankaStartConfig, resetActiveLanka, startLanka } from './bootstrap/index.js';
 export { ILankaRoleFactory, ILankaRoleOpening, TLankaRoleOpener, defineLankaRole } from './role/index.js';
 export { ILankaHostConfig, createLankaHost, getLankaFlags, getLankaHost } from './config/index.js';
 export { I as ILankaFlags, a as ILankaHost, b as ILankaRuntimeConfig } from './ILankaRuntimeConfig-Vl436GWK.js';
-export { I as ILankaLocatorConfig } from './LankaSharedStoreLocator-MvCpav5F.js';
+export { I as ILankaLocatorConfig } from './LankaSharedStoreLocator-zS2kLu-S.js';
 export { lankaLogger } from './logger/index.js';
 export { I as ILankaErrorInit, L as LankaError, T as TLankaErrorKind } from './LankaError-B1HtuIkw.js';
-import './createLankaScope-Bc_vChRs.js';
-import './activeRuntime-FcsSJvUg.js';
-import './ILankaScenarioVM-DuCyPoyT.js';
-import './LankaScenarioLocator-BGQHwf3n.js';
-import './ILankaScenarioMetadata-Bu-yggTZ.js';
-import './ALankaGateway-ExlRGT3D.js';
+import './createLankaScope-BiFxNQgl.js';
+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 './lankaHttpInFlight-Bk1eIuSx.js';

package/dist/index.js

@@ -6,10 +6,10 @@ import {
   createLanka,
   resetActiveLanka,
   startLanka
-} from "./chunk-RYFZCAQ3.js";
-import "./chunk-Q3SOVBIJ.js";
-import "./chunk-FIR4XTBL.js";
-import "./chunk-EWVDJYCC.js";
+} from "./chunk-LMKLLEHA.js";
+import "./chunk-UGXSGQPW.js";
+import "./chunk-5MAQVBI2.js";
+import "./chunk-O5ROO7QF.js";
 import {
   createLankaHost
 } from "./chunk-XESL274R.js";
@@ -20,7 +20,7 @@ import {
 import {
   getLankaHost
 } from "./chunk-RKYKK6MN.js";
-import "./chunk-ILQNYQY5.js";
+import "./chunk-UE2C76OR.js";
 import {
   lankaLogger
 } from "./chunk-C2HP7CRD.js";

package/dist/locator/index.d.ts

@@ -1,24 +1,15 @@
-export { I as ILankaScope } from '../createLankaScope-Bc_vChRs.js';
-export { a as ILankaLocator, I as ILankaLocatorConfig, c as ILankaSharedStoreLocatorConfig, d as ILankaSingletonLocatorConfig } from '../LankaSharedStoreLocator-MvCpav5F.js';
-import { A as ALankaGateway } from '../ALankaGateway-ExlRGT3D.js';
+export { I as ILankaScope } from '../createLankaScope-BiFxNQgl.js';
+export { a as ILankaLocator, I as ILankaLocatorConfig, c as ILankaSharedStoreLocatorConfig, d as ILankaSingletonLocatorConfig } from '../LankaSharedStoreLocator-zS2kLu-S.js';
+import * as GatewaysModule from '@lanka_di/Gateways';
+import { A as ALankaGateway } from '../ALankaGateway-CkW1LbKE.js';
+import * as ScenariosModule from '@lanka_di/Scenarios';
+import * as SingletonsModule from '@lanka_di/Singletons';
+import * as SharedStoresModule from '@lanka_di/SharedStores';
 import { A as ALankaSharedStore } from '../ALankaSharedStore-B7uepuuk.js';
 import '../lankaStandardValidator-CL-r-zEV.js';
 import '@standard-schema/spec';
 import 'zustand/vanilla';
 
-/**
- * The singletons this app publishes to `lanka`.
- *
- * Add one export line per class; the framework derives the locator from these
- * exports, so there is nothing else to register.
- *
- * @example export { AnalyticsService } from "../src/...";
- */
-
-declare namespace SingletonsModule {
-  export {  };
-}
-
 /**
  * The singleton marker: "this class is published by the application in
  * `lankaSingletons`".
@@ -87,19 +78,6 @@ type TLankaSingletons = {
 
 declare const lankaSingletons: TLankaSingletons;
 
-/**
- * The shared stores this app publishes to `lanka`.
- *
- * Add one export line per class; the framework derives the locator from these
- * exports, so there is nothing else to register.
- *
- * @example export { UserSharedStore } from "../src/...";
- */
-
-declare namespace SharedStoresModule {
-  export {  };
-}
-
 /**
  * Shared-store classes read from the consumer's barrel.
  *
@@ -135,19 +113,6 @@ type TLankaSharedStores = {
  */
 declare const lankaSharedStores: TLankaSharedStores;
 
-/**
- * The gateways this app publishes to `lanka`.
- *
- * Add one export line per class; the framework derives the locator from these
- * exports, so there is nothing else to register.
- *
- * @example export { UserGateway } from "../src/...";
- */
-
-declare namespace GatewaysModule {
-  export {  };
-}
-
 /**
  * Gateway classes read from the consumer's barrel.
  *
@@ -190,19 +155,6 @@ type TLankaGateways = {
  */
 declare const lankaGateways: TLankaGateways;
 
-/**
- * The scenarios this app publishes to `lanka`.
- *
- * Add one export line per class; the framework derives the locator from these
- * exports, so there is nothing else to register.
- *
- * @example export { SessionScenario } from "../src/...";
- */
-
-declare namespace ScenariosModule {
-  export {  };
-}
-
 /**
  * Scenario classes read from the consumer's barrel.
  *

package/dist/locator/index.js

@@ -3,7 +3,7 @@ import {
   lankaSharedStores,
   lankaSingletons
 } from "../chunk-DTO27QFR.js";
-import "../chunk-ILQNYQY5.js";
+import "../chunk-UE2C76OR.js";
 import {
   requireActiveRuntime
 } from "../chunk-BGVDPDX4.js";

package/dist/scenario/index.d.ts

@@ -1,6 +1,6 @@
-import { a as ILankaScenario, T as TLankaReplayRequest, b as ILankaEventMetadata, c as TLankaEventBusMiddleware, d as ILankaEventLog, I as ILankaScenarioVM } from '../ILankaScenarioVM-DuCyPoyT.js';
-export { e as TLankaEventBusDecision } from '../ILankaScenarioVM-DuCyPoyT.js';
-export { I as ILankaScenarioMetadata } from '../ILankaScenarioMetadata-Bu-yggTZ.js';
+import { a as ILankaScenario, T as TLankaReplayRequest, b as ILankaEventMetadata, c as TLankaEventBusMiddleware, d as TLankaEventBusObserver, e as ILankaEventLog, I as ILankaScenarioVM } from '../ILankaScenarioVM-DUsI-fSc.js';
+export { f as ILankaEventBusOutcome, g as TLankaEventBusDecision } from '../ILankaScenarioVM-DUsI-fSc.js';
+export { I as ILankaScenarioMetadata } from '../ILankaScenarioMetadata-GoWWNEQL.js';
 
 /**
  * The base of a scenario — a named unit of coordination over the event bus.
@@ -115,6 +115,8 @@ declare const lankaEventBus: Readonly<{
     dispatch: <T>(eventType: string, data?: T, usedBy?: string) => void;
     addMiddleware: <T>(middleware: TLankaEventBusMiddleware<T>) => void;
     removeMiddleware: <T>(middleware: TLankaEventBusMiddleware<T>) => void;
+    addObserver: (observer: TLankaEventBusObserver) => void;
+    removeObserver: (observer: TLankaEventBusObserver) => void;
     getEventLogs: (eventType?: string, limit?: number) => ILankaEventLog[];
     clearEvent: (eventType: string) => void;
     clearAllEvents: () => void;
@@ -201,4 +203,4 @@ declare class LankaScenarioBootstrap {
 /** The one every caller wants. */
 declare const lankaScenarioBootstrap: LankaScenarioBootstrap;
 
-export { ALankaScenario, ILankaEventLog, ILankaEventMetadata, ILankaScenario, type ILankaScenarioConfig, ILankaScenarioVM, TLankaEventBusMiddleware, TLankaReplayRequest, createLankaScenario, lankaEventBus, lankaScenarioBootstrap };
+export { ALankaScenario, ILankaEventLog, ILankaEventMetadata, ILankaScenario, type ILankaScenarioConfig, ILankaScenarioVM, TLankaEventBusMiddleware, TLankaEventBusObserver, TLankaReplayRequest, createLankaScenario, lankaEventBus, lankaScenarioBootstrap };

package/dist/scenario/index.js

@@ -1,10 +1,10 @@
 import {
   lankaScenarioBootstrap
-} from "../chunk-Q3SOVBIJ.js";
+} from "../chunk-UGXSGQPW.js";
 import {
   ALankaScenario,
   lankaEventBus
-} from "../chunk-EWVDJYCC.js";
+} from "../chunk-O5ROO7QF.js";
 import "../chunk-C2HP7CRD.js";
 import "../chunk-D27MREPB.js";
 import "../chunk-BGVDPDX4.js";

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 };