statewire 0.0.0-0 → 0.0.2

package/dist/statewire.d.ts

@@ -0,0 +1,104 @@
+import { ConnectionState } from "./transports/sse.js";
+import { StatewireSessionStoreOptions } from "./client/sessionStore.js";
+import { Statewire } from "./types.js";
+import { ResourceElement } from "@assistant-ui/tap";
+//#region src/statewire.d.ts
+declare const useStatewire: <TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any>(options: StatewireClient.Options<TState, TCommands, TEvent>) => StatewireClient.Helpers<TState, TCommands>;
+declare const StatewireResource: <TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any>(options: StatewireClient.Options<TState, TCommands, TEvent>) => ResourceElement<StatewireClient.Helpers<TState, TCommands>>;
+declare class StatewireClient<TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any> {
+  private readonly root;
+  private disposed;
+  constructor(options: StatewireClient.Options<TState, TCommands, TEvent>);
+  get state(): TState;
+  get connection(): StatewireClient.Connection;
+  get commands(): Statewire.CommandsProxy<TCommands>;
+  subscribe(listener: () => void): () => void;
+  dispose(): void;
+}
+declare namespace StatewireClient {
+  type Options<TState, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any> = {
+    transport: ResourceElement<Statewire<TState, TCommands, TEvent>>;
+    optimistic?: Optimistic<NonNullable<TState>, TCommands>;
+    onEvent?: (event: TEvent, ctx: {
+      state: NonNullable<TState>;
+    }) => void;
+    onStateChange?: (state: NonNullable<TState>, ctx: {
+      changes: Statewire.Changes;
+    }) => void;
+    onCommandChange?: (update: Statewire.CommandUpdate<TCommands>, ctx: {
+      state: NonNullable<TState>;
+    }) => void;
+  };
+  type Helpers<TState, TCommands extends Statewire.Commands = Statewire.Commands> = {
+    /** The statewire's state type — remote statewires include `undefined` until the first attach snapshot applies. */
+    state: TState;
+    /** Identity-stable across renders; reads the current canonical state without subscribing the caller. */
+    getState: () => TState;
+    connection: Connection;
+    commands: Statewire.CommandsProxy<TCommands>;
+  };
+  type Connection = ConnectionState & {
+    reconnect: () => void;
+  };
+  type ConnectionStatus = Connection["status"];
+  /**
+   * Mutate the draft in place; the client records the next state plus the exact
+   * changed paths. Re-run against the new base on every rebase.
+   */
+  type Optimistic<TState, TCommands extends Statewire.Commands = Statewire.Commands> = (draft: TState, command: Statewire.Command<TCommands>, ctx: OptimisticContext) => void;
+  type OptimisticContext = {
+    ts: number;
+    seq: number;
+    clientId?: string;
+  };
+  /**
+   * fate: "aborted" = never sent, "rejected" = the handler refused,
+   * "unknown-command" = no such command, "invalid-params" = the args did not
+   * match the command's schema, "lost" = sent but never covered by an ack,
+   * "crashed" = acked but the processing died, "result-unavailable" = acked
+   * but the result is gone.
+   * cause is which channel settled it: "server" = the server's answer;
+   * the rest are channel deaths the client settled locally.
+   */
+  type SendFailure = {
+    fate: "rejected";
+    cause: "server";
+    message: string;
+    payload?: unknown;
+  } | {
+    fate: "unknown-command";
+    cause: "server";
+  } | {
+    fate: "invalid-params";
+    cause: "server";
+    message: string;
+  } | {
+    fate: "crashed";
+    cause: "server";
+  } | {
+    fate: "result-unavailable";
+    cause: "server" | "unmount" | "stream-gone" | "session-lost" | "superseded";
+  } | {
+    fate: "aborted";
+    cause: "cascade" | "unmount" | "stream-gone" | "session-lost" | "superseded";
+  } | {
+    fate: "lost";
+    cause: "unmount" | "stream-gone" | "session-lost" | "superseded";
+  };
+  type SSEOptions = StatewireSessionStoreOptions & {
+    url: string;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    fetch?: typeof globalThis.fetch;
+    onChange?: (connection: Connection) => void;
+  };
+  type WSOptions = StatewireSessionStoreOptions & {
+    url: string;
+    protocols?: string | string[];
+    query?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    webSocket?: new (url: string, protocols?: string | string[]) => WebSocket;
+    onChange?: (connection: Connection) => void;
+  };
+}
+//#endregion
+export { StatewireClient, StatewireResource, useStatewire };
+//# sourceMappingURL=statewire.d.ts.map

package/dist/statewire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statewire.d.ts","names":[],"sources":["../src/statewire.ts"],"mappings":";;;;;cAaa,eACX,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD,cAEA,SAAS,gBAAgB,QAAQ,QAAQ,WAAW,YACnD,gBAAgB,QAAQ,QAAQ;cA6BtB,oBACX,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD,cAEA,SAAS,gBAAgB,QAAQ,QAAQ,WAAW,YACnD,gBAAgB,gBAAgB,QAAQ,QAAQ;cAGtC,gBACX,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD;mBAEiB;UACT;EAEI,YAAA,SAAS,gBAAgB,QAAQ,QAAQ,WAAW;MAK5D,SAAS;MAIT,cAAc,gBAAgB;MAI9B,YAAY,UAAU,cAAc;EAIxC,UAAU;EAIV;;kBAOe;OACH,QACV,QACA,kBAAkB,UAAU,WAAW,UAAU,UACjD;IAEA,WAAW,gBAAgB,UAAU,QAAQ,WAAW;IACxD,aAAa,WAAW,YAAY,SAAS;IAC7C,WAAW,OAAO,QAAQ;MAAO,OAAO,YAAY;;IACpD,iBACE,OAAO,YAAY,SACnB;MAAO,SAAS,UAAU;;IAE5B,mBACE,QAAQ,UAAU,cAAc,YAChC;MAAO,OAAO,YAAY;;;OAIlB,QACV,QACA,kBAAkB,UAAU,WAAW,UAAU;;IAGjD,OAAO;;IAEP,gBAAgB;IAChB,YAAY;IACZ,UAAU,UAAU,cAAc;;OAGxB,aAAa;IAAoB;;OACjC,mBAAmB;;;;;OAMnB,WACV,QACA,kBAAkB,UAAU,WAAW,UAAU,aAEjD,OAAO,QACP,SAAS,UAAU,QAAQ,YAC3B,KAAK;OAGK;IACV;IACA;IACA;;;;;;;;;;;OAYU;IACN;IAAkB;IAAiB;IAAiB;;IACpD;IAAyB;;IACzB;IAAwB;IAAiB;;IACzC;IAAiB;;IAEjB;IACA;;IAQA;IACA;;IAQA;IACA;;OAGM,aAAa;IACvB;IACA,UAAU,qBAAqB,cAAc,QAAQ;IACrD,eAAe,WAAW;IAC1B,YAAY,YAAY;;OAGd,YAAY;IACtB;IACA;IACA,QACI,gCACO,yBAAyB,QAAQ;IAC5C,iBAAiB,aAAa,kCAAkC;IAChE,YAAY,YAAY"}

package/dist/statewire.js

@@ -0,0 +1,53 @@
+import { LIVE_CONNECTION, useStatewireCore } from "./client/core.js";
+import { useMemo, useRef, useState, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
+import { createTapRoot, flushTapSync, resource, useResource } from "@assistant-ui/tap";
+//#region src/statewire.ts
+const useStatewire = (options) => {
+	const latest = useRef(options);
+	latest.current = options;
+	const value = useResource(options.transport);
+	const core = useStatewireCore(() => latest.current, value);
+	const [subscribe] = useState(() => (listener) => core.subscribe(() => flushTapSync(listener)));
+	const state = useSyncExternalStore(subscribe, core.getState, core.getState);
+	const connection = value.connection ?? LIVE_CONNECTION;
+	return useMemo(() => ({
+		state,
+		getState: core.getState,
+		connection,
+		commands: core.commands
+	}), [
+		state,
+		connection,
+		core
+	]);
+};
+const StatewireResource = (options) => resource(useStatewire)(options);
+var StatewireClient = class {
+	root;
+	disposed = false;
+	constructor(options) {
+		const ClientRoot = () => useStatewire(options);
+		this.root = createTapRoot(ClientRoot);
+	}
+	get state() {
+		return this.root.getValue().getState();
+	}
+	get connection() {
+		return this.root.getValue().connection;
+	}
+	get commands() {
+		return this.root.getValue().commands;
+	}
+	subscribe(listener) {
+		return this.root.subscribe(listener);
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.root.unmount();
+	}
+};
+//#endregion
+export { StatewireClient, StatewireResource, useStatewire };
+
+//# sourceMappingURL=statewire.js.map

package/dist/statewire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statewire.js","names":["useMemo","useRef","useState","useSyncExternalStore","createTapRoot","flushTapSync","resource","useResource","ResourceElement","LIVE_CONNECTION","useStatewireCore","Statewire","ConnectionState","StatewireSessionStoreOptions","useStatewire","Commands","options","StatewireClient","Options","TState","TCommands","TEvent","Helpers","latest","current","value","transport","core","subscribe","listener","state","getState","connection","commands","CommandsProxy","StatewireResource","root","disposed","constructor","ClientRoot","getValue","Connection","dispose","unmount","optimistic","Optimistic","NonNullable","onEvent","event","ctx","onStateChange","changes","Changes","onCommandChange","update","CommandUpdate","reconnect","ConnectionStatus","draft","command","Command","OptimisticContext","ts","seq","clientId","SendFailure","fate","cause","message","payload","SSEOptions","url","headers","HeadersInit","Promise","fetch","globalThis","onChange","WSOptions","protocols","query","Record","webSocket","WebSocket"],"sources":["../src/statewire.ts"],"sourcesContent":["import { useMemo, useRef, useState, useSyncExternalStore } from \"react\";\nimport {\n  createTapRoot,\n  flushTapSync,\n  resource,\n  useResource,\n} from \"@assistant-ui/tap\";\nimport type { ResourceElement } from \"@assistant-ui/tap\";\nimport { LIVE_CONNECTION, useStatewireCore } from \"./client/core\";\nimport type { Statewire } from \"./types\";\nimport type { ConnectionState } from \"./transports/sse\";\nimport type { StatewireSessionStoreOptions } from \"./client/sessionStore\";\n\nexport const useStatewire = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n  TEvent = any,\n>(\n  options: StatewireClient.Options<TState, TCommands, TEvent>,\n): StatewireClient.Helpers<TState, TCommands> => {\n  const latest = useRef(options);\n  latest.current = options;\n\n  const value = useResource(options.transport) as Statewire<unknown>;\n  const core = useStatewireCore(() => latest.current, value);\n  const [subscribe] = useState(\n    () => (listener: () => void) =>\n      core.subscribe(() => flushTapSync(listener)),\n  );\n\n  const state = useSyncExternalStore(\n    subscribe,\n    core.getState,\n    core.getState,\n  ) as TState;\n  const connection = value.connection ?? LIVE_CONNECTION;\n\n  return useMemo(\n    () => ({\n      state,\n      getState: core.getState as () => TState,\n      connection,\n      commands: core.commands as Statewire.CommandsProxy<TCommands>,\n    }),\n    [state, connection, core],\n  );\n};\n\nexport const StatewireResource = <\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n  TEvent = any,\n>(\n  options: StatewireClient.Options<TState, TCommands, TEvent>,\n): ResourceElement<StatewireClient.Helpers<TState, TCommands>> =>\n  resource(useStatewire<TState, TCommands, TEvent>)(options);\n\nexport class StatewireClient<\n  TState,\n  TCommands extends Statewire.Commands = Statewire.Commands,\n  TEvent = any,\n> {\n  private readonly root;\n  private disposed = false;\n\n  constructor(options: StatewireClient.Options<TState, TCommands, TEvent>) {\n    const ClientRoot = () => useStatewire<TState, TCommands, TEvent>(options);\n    this.root = createTapRoot(ClientRoot);\n  }\n\n  get state(): TState {\n    return this.root.getValue().getState();\n  }\n\n  get connection(): StatewireClient.Connection {\n    return this.root.getValue().connection;\n  }\n\n  get commands(): Statewire.CommandsProxy<TCommands> {\n    return this.root.getValue().commands;\n  }\n\n  subscribe(listener: () => void): () => void {\n    return this.root.subscribe(listener);\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.root.unmount();\n  }\n}\n\nexport namespace StatewireClient {\n  export type Options<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n    TEvent = any,\n  > = {\n    transport: ResourceElement<Statewire<TState, TCommands, TEvent>>;\n    optimistic?: Optimistic<NonNullable<TState>, TCommands>;\n    onEvent?: (event: TEvent, ctx: { state: NonNullable<TState> }) => void;\n    onStateChange?: (\n      state: NonNullable<TState>,\n      ctx: { changes: Statewire.Changes },\n    ) => void;\n    onCommandChange?: (\n      update: Statewire.CommandUpdate<TCommands>,\n      ctx: { state: NonNullable<TState> },\n    ) => void;\n  };\n\n  export type Helpers<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = {\n    /** The statewire's state type — remote statewires include `undefined` until the first attach snapshot applies. */\n    state: TState;\n    /** Identity-stable across renders; reads the current canonical state without subscribing the caller. */\n    getState: () => TState;\n    connection: Connection;\n    commands: Statewire.CommandsProxy<TCommands>;\n  };\n\n  export type Connection = ConnectionState & { reconnect: () => void };\n  export type ConnectionStatus = Connection[\"status\"];\n\n  /**\n   * Mutate the draft in place; the client records the next state plus the exact\n   * changed paths. Re-run against the new base on every rebase.\n   */\n  export type Optimistic<\n    TState,\n    TCommands extends Statewire.Commands = Statewire.Commands,\n  > = (\n    draft: TState,\n    command: Statewire.Command<TCommands>,\n    ctx: OptimisticContext,\n  ) => void;\n\n  export type OptimisticContext = {\n    ts: number;\n    seq: number;\n    clientId?: string;\n  };\n\n  /**\n   * fate: \"aborted\" = never sent, \"rejected\" = the handler refused,\n   * \"unknown-command\" = no such command, \"invalid-params\" = the args did not\n   * match the command's schema, \"lost\" = sent but never covered by an ack,\n   * \"crashed\" = acked but the processing died, \"result-unavailable\" = acked\n   * but the result is gone.\n   * cause is which channel settled it: \"server\" = the server's answer;\n   * the rest are channel deaths the client settled locally.\n   */\n  export type SendFailure =\n    | { fate: \"rejected\"; cause: \"server\"; message: string; payload?: unknown }\n    | { fate: \"unknown-command\"; cause: \"server\" }\n    | { fate: \"invalid-params\"; cause: \"server\"; message: string }\n    | { fate: \"crashed\"; cause: \"server\" }\n    | {\n        fate: \"result-unavailable\";\n        cause:\n          | \"server\"\n          | \"unmount\"\n          | \"stream-gone\"\n          | \"session-lost\"\n          | \"superseded\";\n      }\n    | {\n        fate: \"aborted\";\n        cause:\n          | \"cascade\"\n          | \"unmount\"\n          | \"stream-gone\"\n          | \"session-lost\"\n          | \"superseded\";\n      }\n    | {\n        fate: \"lost\";\n        cause: \"unmount\" | \"stream-gone\" | \"session-lost\" | \"superseded\";\n      };\n\n  export type SSEOptions = StatewireSessionStoreOptions & {\n    url: string;\n    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);\n    fetch?: typeof globalThis.fetch;\n    onChange?: (connection: Connection) => void;\n  };\n\n  export type WSOptions = StatewireSessionStoreOptions & {\n    url: string;\n    protocols?: string | string[];\n    query?:\n      | Record<string, string>\n      | (() => Record<string, string> | Promise<Record<string, string>>);\n    webSocket?: new (url: string, protocols?: string | string[]) => WebSocket;\n    onChange?: (connection: Connection) => void;\n  };\n}\n"],"mappings":";;;;AAaA,MAAac,gBAKXE,YAC+C;CAC/C,MAAMO,SAAStB,OAAOe,OAAO;CAC7BO,OAAOC,UAAUR;CAEjB,MAAMS,QAAQlB,YAAYS,QAAQU,SAAS;CAC3C,MAAMC,OAAOjB,uBAAuBa,OAAOC,SAASC,KAAK;CACzD,MAAM,CAACG,aAAa1B,gBACX2B,aACLF,KAAKC,gBAAgBvB,aAAawB,QAAQ,CAAC,CAC/C;CAEA,MAAMC,QAAQ3B,qBACZyB,WACAD,KAAKI,UACLJ,KAAKI,QACP;CACA,MAAMC,aAAaP,MAAMO,cAAcvB;CAEvC,OAAOT,eACE;EACL8B;EACAC,UAAUJ,KAAKI;EACfC;EACAC,UAAUN,KAAKM;CACjB,IACA;EAACH;EAAOE;EAAYL;CAAI,CAC1B;AACF;AAEA,MAAaQ,qBAKXnB,YAEAV,SAASQ,YAAuC,CAAC,CAACE,OAAO;AAE3D,IAAaC,kBAAb,MAIE;CACA;CACA,WAAmB;CAEnBqB,YAAYtB,SAA6D;EACvE,MAAMuB,mBAAmBzB,aAAwCE,OAAO;EACxE,KAAKoB,OAAOhC,cAAcmC,UAAU;CACtC;CAEA,IAAIT,QAAgB;EAClB,OAAO,KAAKM,KAAKI,SAAS,CAAC,CAACT,SAAS;CACvC;CAEA,IAAIC,aAAyC;EAC3C,OAAO,KAAKI,KAAKI,SAAS,CAAC,CAACR;CAC9B;CAEA,IAAIC,WAA+C;EACjD,OAAO,KAAKG,KAAKI,SAAS,CAAC,CAACP;CAC9B;CAEAL,UAAUC,UAAkC;EAC1C,OAAO,KAAKO,KAAKR,UAAUC,QAAQ;CACrC;CAEAa,UAAgB;EACd,IAAI,KAAKL,UAAU;EACnB,KAAKA,WAAW;EAChB,KAAKD,KAAKO,QAAQ;CACpB;AACF"}

package/dist/transports/fake-sse.d.ts

@@ -0,0 +1,12 @@
+import { StatewireEnvelope } from "../client/connection.js";
+//#region src/transports/fake-sse.d.ts
+type FakeStreamHandle = {
+  clientId: string;
+  send: (text: string) => void;
+  close: () => void;
+};
+declare const sseFrame: (envelope: StatewireEnvelope) => string;
+declare const openSSEStream: (streams: Set<FakeStreamHandle>, clientId: string, onOpen: (handle: FakeStreamHandle) => void, signal?: AbortSignal) => Response;
+//#endregion
+export { FakeStreamHandle, openSSEStream, sseFrame };
+//# sourceMappingURL=fake-sse.d.ts.map

package/dist/transports/fake-sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-sse.d.ts","names":[],"sources":["../../src/transports/fake-sse.ts"],"mappings":";;KAEY;EACV;EACA,OAAO;EACP;;cAGW,WAAY,UAAU;cAGtB,gBACX,SAAS,IAAI,mBACb,kBACA,SAAS,QAAQ,2BACjB,SAAS,gBACR"}

package/dist/transports/fake-sse.js

@@ -0,0 +1,39 @@
+//#region src/transports/fake-sse.ts
+const sseFrame = (envelope) => `data: ${JSON.stringify(envelope)}\n\n`;
+const openSSEStream = (streams, clientId, onOpen, signal) => {
+	const encoder = new TextEncoder();
+	let handle;
+	const body = new ReadableStream({
+		start: (controller) => {
+			let open = true;
+			handle = {
+				clientId,
+				send: (text) => {
+					if (open) controller.enqueue(encoder.encode(text));
+				},
+				close: () => {
+					if (!open) return;
+					open = false;
+					streams.delete(handle);
+					controller.close();
+				}
+			};
+			streams.add(handle);
+			onOpen(handle);
+		},
+		cancel: () => {
+			streams.delete(handle);
+		}
+	});
+	signal?.addEventListener("abort", () => {
+		for (const stream of [...streams]) if (stream.clientId === clientId) stream.close();
+	});
+	return new Response(body, {
+		status: 200,
+		headers: { "content-type": "text/event-stream" }
+	});
+};
+//#endregion
+export { openSSEStream, sseFrame };
+
+//# sourceMappingURL=fake-sse.js.map

package/dist/transports/fake-sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-sse.js","names":["StatewireEnvelope","FakeStreamHandle","clientId","send","text","close","sseFrame","envelope","JSON","stringify","openSSEStream","streams","Set","onOpen","handle","signal","AbortSignal","Response","encoder","TextEncoder","body","ReadableStream","Uint8Array","start","controller","open","enqueue","encode","delete","add","cancel","addEventListener","stream","status","headers"],"sources":["../../src/transports/fake-sse.ts"],"sourcesContent":["import type { StatewireEnvelope } from \"../client/connection\";\n\nexport type FakeStreamHandle = {\n  clientId: string;\n  send: (text: string) => void;\n  close: () => void;\n};\n\nexport const sseFrame = (envelope: StatewireEnvelope) =>\n  `data: ${JSON.stringify(envelope)}\\n\\n`;\n\nexport const openSSEStream = (\n  streams: Set<FakeStreamHandle>,\n  clientId: string,\n  onOpen: (handle: FakeStreamHandle) => void,\n  signal?: AbortSignal,\n): Response => {\n  const encoder = new TextEncoder();\n  let handle: FakeStreamHandle;\n  const body = new ReadableStream<Uint8Array>({\n    start: (controller) => {\n      let open = true;\n      handle = {\n        clientId,\n        send: (text) => {\n          if (open) controller.enqueue(encoder.encode(text));\n        },\n        close: () => {\n          if (!open) return;\n          open = false;\n          streams.delete(handle);\n          controller.close();\n        },\n      };\n      streams.add(handle);\n      onOpen(handle);\n    },\n    cancel: () => {\n      streams.delete(handle);\n    },\n  });\n  signal?.addEventListener(\"abort\", () => {\n    for (const stream of [...streams]) {\n      if (stream.clientId === clientId) stream.close();\n    }\n  });\n  return new Response(body, {\n    status: 200,\n    headers: { \"content-type\": \"text/event-stream\" },\n  });\n};\n"],"mappings":";AAQA,MAAaM,YAAYC,aACvB,SAASC,KAAKC,UAAUF,QAAQ,EAAC;AAEnC,MAAaG,iBACXC,SACAT,UACAW,QACAE,WACa;CACb,MAAMG,UAAU,IAAIC,YAAY;CAChC,IAAIL;CACJ,MAAMM,OAAO,IAAIC,eAA2B;EAC1CE,QAAQC,eAAe;GACrB,IAAIC,OAAO;GACXX,SAAS;IACPZ;IACAC,OAAOC,SAAS;KACd,IAAIqB,MAAMD,WAAWE,QAAQR,QAAQS,OAAOvB,IAAI,CAAC;IACnD;IACAC,aAAa;KACX,IAAI,CAACoB,MAAM;KACXA,OAAO;KACPd,QAAQiB,OAAOd,MAAM;KACrBU,WAAWnB,MAAM;IACnB;GACF;GACAM,QAAQkB,IAAIf,MAAM;GAClBD,OAAOC,MAAM;EACf;EACAgB,cAAc;GACZnB,QAAQiB,OAAOd,MAAM;EACvB;CACF,CAAC;CACDC,QAAQgB,iBAAiB,eAAe;EACtC,KAAK,MAAMC,UAAU,CAAC,GAAGrB,OAAO,GAC9B,IAAIqB,OAAO9B,aAAaA,UAAU8B,OAAO3B,MAAM;CAEnD,CAAC;CACD,OAAO,IAAIY,SAASG,MAAM;EACxBa,QAAQ;EACRC,SAAS,EAAE,gBAAgB,oBAAoB;CACjD,CAAC;AACH"}

package/dist/transports/fixtures.d.ts

@@ -0,0 +1,33 @@
+import { StatewireHost } from "../host.js";
+import { Statewire } from "../types.js";
+import "../index.js";
+//#region src/transports/fixtures.d.ts
+/** Let several rounds of queued microtasks and op batches drain. */
+declare const settle: () => Promise<void>;
+/** A minimal statewire host element: `{ count }` state with an `increment` command. */
+declare const createCounterElement: () => import("@assistant-ui/tap").ResourceElement<{
+  state: {
+    count: number;
+  };
+  commands: Statewire.CommandsProxy<StatewireHost.HandledCommands<{
+    increment: () => void;
+  }>>;
+  emit: (event: unknown) => void;
+}>;
+/** Serialize a command frame as a client would send it over a socket. */
+declare const commandFrame: (method: string, seq: number, params?: unknown[]) => string;
+type SocketRecorder = {
+  sent: string[];
+  closes: {
+    code?: number;
+    reason?: string;
+  }[];
+  last: () => any;
+  send: (data: string) => void;
+  close: (code?: number, reason?: string) => void;
+};
+/** Record sent frames and close calls; `last()` parses the latest frame. */
+declare const createSocketRecorder: () => SocketRecorder;
+//#endregion
+export { SocketRecorder, commandFrame, createCounterElement, createSocketRecorder, settle };
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/transports/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","names":[],"sources":["../../src/transports/fixtures.ts"],"mappings":";;;;;cASa,cAAM;;cAKN,wDAAoB;;;;YAApB,UAAA,cAAA,cAAA;;;;;;cAaA,eACX,gBACA,aACA;KAGU;EACV;EACA;IAAU;IAAe;;EACzB;EACA,OAAO;EACP,QAAQ,eAAe;;;cAIZ,4BAA2B"}

package/dist/transports/fixtures.js

@@ -0,0 +1,50 @@
+import { useStatewireCommands, useStatewireEmit, useStatewireState } from "../host/host.js";
+import "../host.js";
+import { tick } from "./testing.js";
+import { resource } from "@assistant-ui/tap";
+//#region src/transports/fixtures.ts
+/** Let several rounds of queued microtasks and op batches drain. */
+const settle = async () => {
+	for (let i = 0; i < 3; i++) await tick();
+};
+/** A minimal statewire host element: `{ count }` state with an `increment` command. */
+const createCounterElement = () => resource(() => {
+	const [state] = useStatewireState(() => ({ count: 0 }));
+	const emit = useStatewireEmit();
+	return {
+		state,
+		commands: useStatewireCommands({ increment: () => {
+			state.count += 1;
+		} }),
+		emit
+	};
+})();
+/** Serialize a command frame as a client would send it over a socket. */
+const commandFrame = (method, seq, params = []) => JSON.stringify({
+	method,
+	params,
+	seq
+});
+/** Record sent frames and close calls; `last()` parses the latest frame. */
+const createSocketRecorder = () => {
+	const sent = [];
+	const closes = [];
+	return {
+		sent,
+		closes,
+		last: () => JSON.parse(sent.at(-1)),
+		send: (data) => {
+			sent.push(data);
+		},
+		close: (code, reason) => {
+			closes.push({
+				...code !== void 0 && { code },
+				...reason !== void 0 && { reason }
+			});
+		}
+	};
+};
+//#endregion
+export { commandFrame, createCounterElement, createSocketRecorder, settle };
+
+//# sourceMappingURL=fixtures.js.map

package/dist/transports/fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.js","names":["resource","useStatewireCommands","useStatewireEmit","useStatewireState","tick","settle","i","createCounterElement","state","count","emit","commands","increment","commandFrame","method","seq","params","JSON","stringify","SocketRecorder","sent","closes","code","reason","last","send","data","close","createSocketRecorder","parse","at","push","undefined"],"sources":["../../src/transports/fixtures.ts"],"sourcesContent":["import { resource } from \"@assistant-ui/tap\";\nimport {\n  useStatewireCommands,\n  useStatewireEmit,\n  useStatewireState,\n} from \"../host\";\nimport { tick } from \"./testing\";\n\n/** Let several rounds of queued microtasks and op batches drain. */\nexport const settle = async () => {\n  for (let i = 0; i < 3; i++) await tick();\n};\n\n/** A minimal statewire host element: `{ count }` state with an `increment` command. */\nexport const createCounterElement = () =>\n  resource(() => {\n    const [state] = useStatewireState(() => ({ count: 0 }));\n    const emit = useStatewireEmit();\n    const commands = useStatewireCommands({\n      increment: () => {\n        state.count += 1;\n      },\n    });\n    return { state, commands, emit };\n  })();\n\n/** Serialize a command frame as a client would send it over a socket. */\nexport const commandFrame = (\n  method: string,\n  seq: number,\n  params: unknown[] = [],\n) => JSON.stringify({ method, params, seq });\n\nexport type SocketRecorder = {\n  sent: string[];\n  closes: { code?: number; reason?: string }[];\n  last: () => any;\n  send: (data: string) => void;\n  close: (code?: number, reason?: string) => void;\n};\n\n/** Record sent frames and close calls; `last()` parses the latest frame. */\nexport const createSocketRecorder = (): SocketRecorder => {\n  const sent: string[] = [];\n  const closes: { code?: number; reason?: string }[] = [];\n  return {\n    sent,\n    closes,\n    last: () => JSON.parse(sent.at(-1)!),\n    send: (data) => {\n      sent.push(data);\n    },\n    close: (code, reason) => {\n      closes.push({\n        ...(code !== undefined && { code }),\n        ...(reason !== undefined && { reason }),\n      });\n    },\n  };\n};\n"],"mappings":";;;;;;AASA,MAAaK,SAAS,YAAY;CAChC,KAAK,IAAIC,IAAI,GAAGA,IAAI,GAAGA,KAAK,MAAMF,KAAK;AACzC;;AAGA,MAAaG,6BACXP,eAAe;CACb,MAAM,CAACQ,SAASL,yBAAyB,EAAEM,OAAO,EAAE,EAAE;CACtD,MAAMC,OAAOR,iBAAiB;CAM9B,OAAO;EAAEM;EAAOG,UALCV,qBAAqB,EACpCW,iBAAiB;GACfJ,MAAMC,SAAS;EACjB,EACF,CACgBE;EAAUD;CAAK;AACjC,CAAC,CAAC,CAAC;;AAGL,MAAaG,gBACXC,QACAC,KACAC,SAAoB,CAAA,MACjBC,KAAKC,UAAU;CAAEJ;CAAQE;CAAQD;AAAI,CAAC;;AAW3C,MAAaa,6BAA6C;CACxD,MAAMR,OAAiB,CAAA;CACvB,MAAMC,SAA+C,CAAA;CACrD,OAAO;EACLD;EACAC;EACAG,YAAYP,KAAKY,MAAMT,KAAKU,GAAG,EAAE,CAAE;EACnCL,OAAOC,SAAS;GACdN,KAAKW,KAAKL,IAAI;EAChB;EACAC,QAAQL,MAAMC,WAAW;GACvBF,OAAOU,KAAK;IACV,GAAIT,SAASU,KAAAA,KAAa,EAAEV,KAAK;IACjC,GAAIC,WAAWS,KAAAA,KAAa,EAAET,OAAO;GACvC,CAAC;EACH;CACF;AACF"}

package/dist/transports/remote.d.ts

@@ -0,0 +1,12 @@
+import { RemoteLink, StatewireRemoteProps } from "./sse.js";
+import { StatewireSessionStoreOptions } from "../client/sessionStore.js";
+import { StatewireClient } from "../statewire.js";
+import { Statewire } from "../types.js";
+//#region src/transports/remote.d.ts
+declare const useStatewireRemote: <TOptions extends {
+  url: string;
+  onChange?: (connection: StatewireClient.Connection) => void;
+} & StatewireSessionStoreOptions>(options: TOptions, useLink: (options: TOptions, ctx: StatewireRemoteProps) => RemoteLink) => Statewire<any, any, any>;
+//#endregion
+export { useStatewireRemote };
+//# sourceMappingURL=remote.d.ts.map

package/dist/transports/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","names":[],"sources":["../../src/transports/remote.ts"],"mappings":";;;;;cAQa,qBACX;EACE;EACA,YAAY,YAAY,gBAAgB;IACtC,8BAEJ,SAAS,UACT,UAAU,SAAS,UAAU,KAAK,yBAAyB,eAC1D"}

package/dist/transports/remote.js

@@ -0,0 +1,21 @@
+import { useStatewireEmit } from "../host/host.js";
+import { setTransport, useStatewireSession } from "../client/session.js";
+import { useEffect } from "@assistant-ui/tap/react-shim";
+//#region src/transports/remote.ts
+const useStatewireRemote = (options, useLink) => {
+	const emit = useStatewireEmit();
+	const s = useStatewireSession({ sessionStore: options.sessionStore }, emit);
+	const conn = useLink(options, s.ctx);
+	useEffect(() => setTransport(s, conn), [s, conn]);
+	return {
+		state: s.canonical,
+		commands: s.commands,
+		emit,
+		connection: conn.connection,
+		source: s.source
+	};
+};
+//#endregion
+export { useStatewireRemote };
+
+//# sourceMappingURL=remote.js.map

package/dist/transports/remote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.js","names":["useEffect","useStatewireEmit","Statewire","setTransport","useStatewireSession","StatewireSessionStoreOptions","StatewireClient","RemoteLink","StatewireRemoteProps","useStatewireRemote","url","onChange","connection","Connection","options","TOptions","useLink","ctx","emit","s","sessionStore","conn","state","canonical","commands","source"],"sources":["../../src/transports/remote.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useStatewireEmit } from \"../host/host\";\nimport type { Statewire } from \"../types\";\nimport { setTransport, useStatewireSession } from \"../client/session\";\nimport type { StatewireSessionStoreOptions } from \"../client/sessionStore\";\nimport type { StatewireClient } from \"../statewire\";\nimport type { RemoteLink, StatewireRemoteProps } from \"./sse\";\n\nexport const useStatewireRemote = <\n  TOptions extends {\n    url: string;\n    onChange?: (connection: StatewireClient.Connection) => void;\n  } & StatewireSessionStoreOptions,\n>(\n  options: TOptions,\n  useLink: (options: TOptions, ctx: StatewireRemoteProps) => RemoteLink,\n): Statewire<any, any, any> => {\n  const emit = useStatewireEmit<any>();\n  const s = useStatewireSession({ sessionStore: options.sessionStore }, emit);\n  const conn = useLink(options, s.ctx);\n  useEffect(() => setTransport(s, conn), [s, conn]);\n\n  return {\n    state: s.canonical,\n    commands: s.commands,\n    emit,\n    connection: conn.connection,\n    source: s.source,\n  };\n};\n"],"mappings":";;;;AAQA,MAAaS,sBAMXK,SACAE,YAC6B;CAC7B,MAAME,OAAOjB,iBAAsB;CACnC,MAAMkB,IAAIf,oBAAoB,EAAEgB,cAAcN,QAAQM,aAAa,GAAGF,IAAI;CAC1E,MAAMG,OAAOL,QAAQF,SAASK,EAAEF,GAAG;CACnCjB,gBAAgBG,aAAagB,GAAGE,IAAI,GAAG,CAACF,GAAGE,IAAI,CAAC;CAEhD,OAAO;EACLC,OAAOH,EAAEI;EACTC,UAAUL,EAAEK;EACZN;EACAN,YAAYS,KAAKT;EACjBa,QAAQN,EAAEM;CACZ;AACF"}

package/dist/transports/sse-parser.d.ts

@@ -0,0 +1,5 @@
+//#region src/transports/sse-parser.d.ts
+declare const createSseParser: () => ((chunk: string) => string[]);
+//#endregion
+export { createSseParser };
+//# sourceMappingURL=sse-parser.d.ts.map

package/dist/transports/sse-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-parser.d.ts","names":[],"sources":["../../src/transports/sse-parser.ts"],"mappings":";cAAa,yBAAwB"}

package/dist/transports/sse-parser.js

@@ -0,0 +1,26 @@
+//#region src/transports/sse-parser.ts
+const createSseParser = () => {
+	let buffer = "";
+	let dataLines = [];
+	return (chunk) => {
+		const events = [];
+		buffer += chunk;
+		const held = buffer.endsWith("\r") ? "\r" : "";
+		const lines = buffer.slice(0, buffer.length - held.length).split(/\r\n|\r|\n/);
+		buffer = lines.pop() + held;
+		for (const line of lines) {
+			if (line === "") {
+				if (dataLines.length > 0) events.push(dataLines.join("\n"));
+				dataLines = [];
+				continue;
+			}
+			const match = /^data(?:: ?(.*))?$/.exec(line);
+			if (match) dataLines.push(match[1] ?? "");
+		}
+		return events;
+	};
+};
+//#endregion
+export { createSseParser };
+
+//# sourceMappingURL=sse-parser.js.map

package/dist/transports/sse-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-parser.js","names":["createSseParser","chunk","buffer","dataLines","events","held","endsWith","lines","slice","length","split","pop","line","push","join","match","exec"],"sources":["../../src/transports/sse-parser.ts"],"sourcesContent":["export const createSseParser = (): ((chunk: string) => string[]) => {\n  let buffer = \"\";\n  let dataLines: string[] = [];\n\n  return (chunk: string) => {\n    const events: string[] = [];\n    buffer += chunk;\n    const held = buffer.endsWith(\"\\r\") ? \"\\r\" : \"\";\n    const lines = buffer\n      .slice(0, buffer.length - held.length)\n      .split(/\\r\\n|\\r|\\n/);\n    buffer = lines.pop()! + held;\n    for (const line of lines) {\n      if (line === \"\") {\n        if (dataLines.length > 0) events.push(dataLines.join(\"\\n\"));\n        dataLines = [];\n        continue;\n      }\n      const match = /^data(?:: ?(.*))?$/.exec(line);\n      if (match) dataLines.push(match[1] ?? \"\");\n    }\n    return events;\n  };\n};\n"],"mappings":";AAAA,MAAaA,wBAAuD;CAClE,IAAIE,SAAS;CACb,IAAIC,YAAsB,CAAA;CAE1B,QAAQF,UAAkB;EACxB,MAAMG,SAAmB,CAAA;EACzBF,UAAUD;EACV,MAAMI,OAAOH,OAAOI,SAAS,IAAI,IAAI,OAAO;EAC5C,MAAMC,QAAQL,OACXM,MAAM,GAAGN,OAAOO,SAASJ,KAAKI,MAAM,CAAC,CACrCC,MAAM,YAAY;EACrBR,SAASK,MAAMI,IAAI,IAAKN;EACxB,KAAK,MAAMO,QAAQL,OAAO;GACxB,IAAIK,SAAS,IAAI;IACf,IAAIT,UAAUM,SAAS,GAAGL,OAAOS,KAAKV,UAAUW,KAAK,IAAI,CAAC;IAC1DX,YAAY,CAAA;IACZ;GACF;GACA,MAAMY,QAAQ,qBAAqBC,KAAKJ,IAAI;GAC5C,IAAIG,OAAOZ,UAAUU,KAAKE,MAAM,MAAM,EAAE;EAC1C;EACA,OAAOX;CACT;AACF"}

package/dist/transports/sse.d.ts

@@ -0,0 +1,64 @@
+import { StatewireHost } from "../host.js";
+import { StatewireResponse } from "../client/connection.js";
+import { StatewireClient } from "../statewire.js";
+import { Statewire } from "../types.js";
+import { ResourceElement } from "@assistant-ui/tap";
+//#region src/transports/sse.d.ts
+type StatewireRemoteProps = {
+  clientId: string;
+  onSnapshot: (args: {
+    ops: unknown[];
+    lastSeq: number;
+  }) => void;
+  onOps: (args: {
+    ops: unknown[];
+    res?: StatewireResponse[];
+    ack?: number;
+  }) => void;
+  onFinish: (args: StatewireHost.Fin) => void;
+};
+type StatewireWireCommand = {
+  method: string;
+  params: readonly unknown[];
+};
+type StatewireSubmitResult = {
+  type: "receipt";
+  response?: StatewireResponse;
+} | {
+  type: "rejected";
+  message: string;
+} | {
+  type: "seq-gap";
+} | {
+  type: "unknown-client";
+} | {
+  type: "stale-lease";
+};
+type ConnectionState = {
+  status: "connecting";
+} | {
+  status: "live";
+} | {
+  status: "reconnecting";
+  cause: "dropped" | "evicted" | "error";
+  attempt: number;
+  nextRetryAt: number;
+  lastError?: string;
+  message?: string;
+} | {
+  status: "gone";
+  message?: string;
+  payload?: unknown;
+};
+/** The live wire a remote session drives: connection status plus command POST. */
+type RemoteLink = {
+  connection: StatewireClient.Connection;
+  send: (args: {
+    seq: number;
+    command: StatewireWireCommand;
+  }) => Promise<StatewireSubmitResult>;
+};
+declare const StatewireSSE: <TState = any, TCommands extends Statewire.Commands = Statewire.Commands, TEvent = any>(options: StatewireClient.SSEOptions) => ResourceElement<Statewire<TState | undefined, TCommands, TEvent>>;
+//#endregion
+export { ConnectionState, RemoteLink, StatewireRemoteProps, StatewireSSE, StatewireSubmitResult, StatewireWireCommand };
+//# sourceMappingURL=sse.d.ts.map

package/dist/transports/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","names":[],"sources":["../../src/transports/sse.ts"],"mappings":";;;;;;KAuBY;EACV;EACA,aAAa;IAAQ;IAAgB;;EACrC,QAAQ;IACN;IACA,MAAM;IACN;;EAEF,WAAW,MAAM,cAAc;;KAGrB;EACV;EACA;;KAGU;EACN;EAAiB,WAAW;;EAC5B;EAAkB;;EAClB;;EACA;;EACA;;KAEM;EACN;;EACA;;EAEA;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAgB;EAAkB;;;KAG5B;EACV,YAAY,gBAAgB;EAC5B,OAAO;IACL;IACA,SAAS;QACL,QAAQ;;cAmMH,eACX,cACA,kBAAkB,UAAU,WAAW,UAAU,UACjD,cAEA,SAAS,gBAAgB,eACtB,gBAAgB,UAAU,oBAAoB,WAAW"}

package/dist/transports/sse.js

@@ -0,0 +1,137 @@
+import { encodeParams, reviveResponse } from "../wire/meta.js";
+import { createSseParser } from "./sse-parser.js";
+import { timing } from "../client/timing.js";
+import { classify, handleEnvelope, overloadedError, parseRetryAfter, useStatewireConn } from "../client/connection.js";
+import { useStatewireRemote } from "./remote.js";
+import { useRef, useState } from "@assistant-ui/tap/react-shim";
+import { flushTapSync, resource } from "@assistant-ui/tap";
+//#region src/transports/sse.ts
+const baseUrl = (options) => options.url.replace(/\/$/, "");
+const requestHeaders = async (options, extra) => {
+	const { headers } = options;
+	const merged = new Headers(typeof headers === "function" ? await headers() : headers);
+	for (const [name, value] of Object.entries(extra)) merged.set(name, value);
+	return merged;
+};
+const timedFetch = async (options, input, init, timeout) => {
+	try {
+		return await (options.fetch ?? globalThis.fetch)(input, init);
+	} catch {
+		throw classify(timeout);
+	}
+};
+const consume = async (c, reader, heartbeat, dead) => {
+	const decoder = new TextDecoder();
+	const parse = createSseParser();
+	for (;;) {
+		const timer = setTimeout(() => heartbeat.abort(), timing.heartbeatTimeoutMs);
+		let result;
+		try {
+			result = await reader.read();
+		} catch {
+			throw classify(heartbeat.signal);
+		} finally {
+			clearTimeout(timer);
+		}
+		if (result.done) return "ended";
+		for (const data of parse(decoder.decode(result.value, { stream: true }))) {
+			if (dead()) return "ended";
+			const env = JSON.parse(data);
+			const done = flushTapSync(() => handleEnvelope(c, env));
+			if (done) return done;
+		}
+	}
+};
+const attemptStream = async (c, options, abort) => {
+	const headers = await requestHeaders(options, {
+		"Statewire-Client-Id": c.ctx.clientId,
+		accept: "text/event-stream"
+	});
+	const heartbeat = new AbortController();
+	const headerTimer = setTimeout(() => heartbeat.abort(), timing.heartbeatTimeoutMs);
+	let res;
+	try {
+		res = await timedFetch(options, `${baseUrl(options)}/stream`, {
+			headers,
+			cache: "no-store",
+			signal: AbortSignal.any([abort.signal, heartbeat.signal])
+		}, heartbeat.signal);
+	} finally {
+		clearTimeout(headerTimer);
+	}
+	if (res.status === 429 || res.status === 503) throw overloaded(res);
+	if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`);
+	const reader = res.body.getReader();
+	try {
+		return await consume(c, reader, heartbeat, () => abort.signal.aborted);
+	} finally {
+		reader.cancel().catch(() => {});
+	}
+};
+const overloaded = (res) => overloadedError(parseRetryAfter(res.headers.get("Retry-After")));
+const sendCommand = async (c, options, { seq, command }) => {
+	const timeout = AbortSignal.timeout(timing.heartbeatTimeoutMs);
+	const res = await timedFetch(options, `${baseUrl(options)}/commands`, {
+		method: "POST",
+		headers: await requestHeaders(options, {
+			"content-type": "application/json",
+			"Statewire-Client-Id": c.ctx.clientId,
+			"Statewire-Command-Seq": String(seq),
+			...c.lease !== null && { "Statewire-Lease": c.lease }
+		}),
+		body: JSON.stringify({
+			method: command.method,
+			...encodeParams(command.params)
+		}),
+		signal: AbortSignal.any([c.lifetime?.signal ?? AbortSignal.abort(), timeout])
+	}, timeout);
+	if (res.ok) {
+		let body;
+		try {
+			body = await res.json();
+		} catch {
+			return {
+				type: "rejected",
+				message: "statewire: protocol error: malformed /commands receipt body"
+			};
+		}
+		return body?.res !== void 0 ? {
+			type: "receipt",
+			response: reviveResponse(body.res)
+		} : { type: "receipt" };
+	}
+	if (res.status === 409 || res.status === 412 || res.status === 423) {
+		const verdict = res.status === 409 ? "seq-gap" : res.status === 412 ? "unknown-client" : "stale-lease";
+		if ((await res.json().catch(() => null))?.error === verdict) return { type: verdict };
+		throw new Error(`HTTP ${res.status}`);
+	}
+	if (res.status === 429 || res.status === 503) throw overloaded(res);
+	if (res.status >= 400 && res.status < 500) return {
+		type: "rejected",
+		message: `HTTP ${res.status}`
+	};
+	throw new Error(`HTTP ${res.status}`);
+};
+const useSseLink = (options, ctx) => {
+	const latest = useRef(options);
+	latest.current = options;
+	const c_0 = useStatewireConn({
+		url: options.url,
+		onChange: options.onChange,
+		ctx,
+		attemptOnce: (c, abort) => attemptStream(c, options, abort)
+	});
+	const [link] = useState(() => ({
+		get connection() {
+			return c_0.connection;
+		},
+		send: (args) => sendCommand(c_0, latest.current, args)
+	}));
+	return link;
+};
+const useStatewireSSE = (options) => useStatewireRemote(options, useSseLink);
+const StatewireSSE = resource(useStatewireSSE);
+//#endregion
+export { StatewireSSE };
+
+//# sourceMappingURL=sse.js.map