foldkit-primitives 0.15.3 → 0.16.0

package/dist/net/online.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const OnlineModel: Schema.Struct<{
+  readonly online: Schema.Boolean;
+}>;
+export type OnlineModel = typeof OnlineModel.Type;
+export declare const OnlineMessage: import("foldkit/message").MessageUnion<{
+  readonly Changed: {
+    online: Schema.Boolean;
+  };
+}>;
+export type OnlineMessage = typeof OnlineMessage.Type;
+/**
+ * Online presence as a bundle: `online` in the Model, kept current by the
+ * window's online/offline events. The browser reports facts; the Model owns
+ * the state, so presence replays like any other transition.
+ */
+export declare const Online: Bundle.Bundle<"Online", void, {
+  readonly online: boolean;
+}, {
+  readonly _tag: "Changed";
+  readonly online: boolean;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=online.d.ts.map

package/dist/net/online.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"online.d.ts","names":[],"sources":["../../src/net/online.ts"],"mappings":";;qBAKa,aAAW,OAAA;;;YACZ,qBAAqB,YAAY;qBAEhC,yCAAa;;IAAmC,QAAM,OAAA;;;YACvD,uBAAuB,cAAc;;;;;;qBAuBpC,QAAM,OAAA"}

package/dist/net/online.js

@@ -0,0 +1,26 @@
+import { Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+// src/net/online.ts
+const OnlineModel = Schema.Struct({ online: Schema.Boolean });
+const OnlineMessage = defineMessageUnion({ Changed: { online: Schema.Boolean } });
+const presenceStream = () => {
+	if (typeof window === "undefined") return Stream.empty;
+	return Stream.mergeAll([Stream.fromEventListener(window, "online").pipe(Stream.map(() => OnlineMessage.Changed({ online: true }))), Stream.fromEventListener(window, "offline").pipe(Stream.map(() => OnlineMessage.Changed({ online: false })))], { concurrency: "unbounded" });
+};
+/**
+* Online presence as a bundle: `online` in the Model, kept current by the
+* window's online/offline events. The browser reports facts; the Model owns
+* the state, so presence replays like any other transition.
+*/
+const Online = Bundle.make("Online", {
+	Model: OnlineModel,
+	Message: OnlineMessage,
+	init: () => ({ model: { online: typeof navigator !== "undefined" && typeof navigator.onLine === "boolean" ? navigator.onLine : true } }),
+	update: (model, message) => message.online === model.online ? { model } : { model: { online: message.online } },
+	subscriptions: () => Subscription.make()(() => ({ changes: Subscription.persistentEntry(presenceStream()) }))
+});
+export { Online, OnlineMessage, OnlineModel };
+
+//# sourceMappingURL=online.js.map

package/dist/net/online.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"online.js","names":[],"sources":["../../src/net/online.ts"],"sourcesContent":["import { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport { Bundle } from 'foldkit-bundle'\n\nexport const OnlineModel = Schema.Struct({ online: Schema.Boolean })\nexport type OnlineModel = typeof OnlineModel.Type\n\nexport const OnlineMessage = defineMessageUnion({ Changed: { online: Schema.Boolean } })\nexport type OnlineMessage = typeof OnlineMessage.Type\n\nconst presenceStream = (): Stream.Stream<OnlineMessage> => {\n  // No window (SSR): nothing to listen to, so the slice keeps its default.\n  if (typeof window === 'undefined') return Stream.empty\n  return Stream.mergeAll(\n    [\n      Stream.fromEventListener(window, 'online').pipe(\n        Stream.map(() => OnlineMessage.Changed({ online: true })),\n      ),\n      Stream.fromEventListener(window, 'offline').pipe(\n        Stream.map(() => OnlineMessage.Changed({ online: false })),\n      ),\n    ],\n    { concurrency: 'unbounded' },\n  )\n}\n\n/**\n * Online presence as a bundle: `online` in the Model, kept current by the\n * window's online/offline events. The browser reports facts; the Model owns\n * the state, so presence replays like any other transition.\n */\nexport const Online = Bundle.make('Online', {\n  Model: OnlineModel,\n  Message: OnlineMessage,\n  init: () => ({\n    // navigator.onLine is the browser's current answer; true elsewhere (SSR).\n    model: {\n      online:\n        typeof navigator !== 'undefined' && typeof navigator.onLine === 'boolean'\n          ? navigator.onLine\n          : true,\n    },\n  }),\n  update: (model, message) =>\n    message.online === model.online ? { model } : { model: { online: message.online } },\n  subscriptions: (): Subscription.Subscriptions<OnlineModel, OnlineMessage> =>\n    Subscription.make<OnlineModel, OnlineMessage>()(() => ({\n      changes: Subscription.persistentEntry(presenceStream()),\n    })),\n})\n"],"mappings":";;;;;AAKA,MAAa,cAAc,OAAO,OAAO,EAAE,QAAQ,OAAO,QAAQ,CAAC;AAGnE,MAAa,gBAAgB,mBAAmB,EAAE,SAAS,EAAE,QAAQ,OAAO,QAAQ,EAAE,CAAC;AAGvF,MAAM,uBAAqD;CAEzD,IAAI,OAAO,WAAW,aAAa,OAAO,OAAO;CACjD,OAAO,OAAO,SACZ,CACE,OAAO,kBAAkB,QAAQ,QAAQ,CAAC,CAAC,KACzC,OAAO,UAAU,cAAc,QAAQ,EAAE,QAAQ,KAAK,CAAC,CAAC,CAC1D,GACA,OAAO,kBAAkB,QAAQ,SAAS,CAAC,CAAC,KAC1C,OAAO,UAAU,cAAc,QAAQ,EAAE,QAAQ,MAAM,CAAC,CAAC,CAC3D,CACF,GACA,EAAE,aAAa,YAAY,CAC7B;AACF;;;;;;AAOA,MAAa,SAAS,OAAO,KAAK,UAAU;CAC1C,OAAO;CACP,SAAS;CACT,aAAa,EAEX,OAAO,EACL,QACE,OAAO,cAAc,eAAe,OAAO,UAAU,WAAW,YAC5D,UAAU,SACV,KACR,EACF;CACA,SAAS,OAAO,YACd,QAAQ,WAAW,MAAM,SAAS,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,QAAQ,QAAQ,OAAO,EAAE;CACpF,qBACE,aAAa,KAAiC,CAAC,QAAQ,EACrD,SAAS,aAAa,gBAAgB,eAAe,CAAC,EACxD,EAAE;AACN,CAAC"}

package/dist/net/sharedHost.d.ts

@@ -0,0 +1,64 @@
+import { Schema } from "effect";
+/** One conversation a page opened: its port, and a signal that aborts once the page is gone. */
+export interface Conversation {
+  readonly port: MessagePort;
+  readonly signal: AbortSignal;
+}
+/** What the host does with each conversation, told what the page opened it for. */
+export type ConversationHandler<Opening> = (opening: Opening, conversation: Conversation) => void;
+/** Starts the host, once, the first time a conversation needs it. */
+export type StartHost<Opening> = () => ConversationHandler<Opening> | Promise<ConversationHandler<Opening>>;
+/** Where `SharedHost` runs the host: in a SharedWorker, or in the page when there is none. */
+export interface SharedHostOptions<Opening> {
+  /**
+   * The SharedWorker whose entry calls `serve`. Constructed by the
+   * application, since a bundler finds a worker only in a literal
+   * `new SharedWorker(new URL('./worker.ts', import.meta.url), …)`.
+   */
+  readonly worker: () => {
+    readonly port: MessagePort;
+  };
+  /** The host, for a browser without SharedWorker: started in the top document. */
+  readonly inPage: StartHost<Opening>;
+}
+/** A page's way to the host. */
+export interface SharedHostConnection<Opening> {
+  /** Opens a conversation for `opening`, returning the page's end of it. */
+  readonly open: (opening: Opening) => MessagePort;
+}
+export interface SharedHost<Opening> {
+  readonly name: string;
+  /** A SharedWorker's entry: hands the host every conversation a page opens. */
+  readonly serve: (start: StartHost<Opening>) => void;
+  /**
+   * A page's connection: through the SharedWorker, or, without one, to the
+   * host in the top document. Call it in the top document too when that
+   * document frames the pages, so that it is the one the frames meet.
+   */
+  readonly connect: (options: SharedHostOptions<Opening>) => SharedHostConnection<Opening>;
+}
+/**
+ * A shared host: its `name`, which keeps two on one origin apart, and
+ * the schema of what opens a conversation, which the host decodes before
+ * anything else, ignoring a message that does not decode.
+ */
+declare const define: <Opening, Encoded>(options: {
+  readonly name: string;
+  readonly opening: Schema.Codec<Opening, Encoded, never, never>;
+}) => SharedHost<Opening>;
+/**
+ * One server in the browser for many documents: every tab and frame of an
+ * application meets the same host. A page opens conversations, each a
+ * `MessagePort` with a decoded opening that says what it is for; the host, in
+ * a SharedWorker shared by every tab, or in the top document where there is no
+ * SharedWorker, is handed each one with a signal that aborts when the page
+ * that opened it is gone.
+ *
+ * It owns the host's lifetime and the routing of conversations, nothing
+ * spoken over them: Sync's `portSocket` and Remote's `port` do that.
+ */
+export declare const SharedHost: {
+  define: typeof define;
+};
+export {};
+//# sourceMappingURL=sharedHost.d.ts.map

package/dist/net/sharedHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharedHost.d.ts","names":[],"sources":["../../src/net/sharedHost.ts"],"mappings":";;iBAGiB;WACN,MAAM;WACN,QAAQ;;;YAIP,oBAAoB,YAAY,SAAS,SAAS,cAAc;;YAGhE,UAAU,iBAClB,oBAAoB,WACpB,QAAQ,oBAAoB;;iBAGf,kBAAkB;;;;;;WAMxB;aAAyB,MAAM;;;WAE/B,QAAQ,UAAU;;;iBAIZ,qBAAqB;;WAE3B,OAAO,SAAS,YAAY;;iBAGtB,WAAW;WACjB;;WAEA,QAAQ,OAAO,UAAU;;;;;;WAMzB,UAAU,SAAS,kBAAkB,aAAa,qBAAqB;;;;;;;cAQ5E,SAAU,SAAS,SAAO;WACrB;WACA,SAAS,OAAO,MAAM,SAAS;MACtC,WAAW;;;;;;;;;;;;qBA4IF"}

package/dist/net/sharedHost.js

@@ -0,0 +1,124 @@
+import { Option, Schema } from "effect";
+// src/net/sharedHost.ts
+/**
+* A shared host: its `name`, which keeps two on one origin apart, and
+* the schema of what opens a conversation, which the host decodes before
+* anything else, ignoring a message that does not decode.
+*/
+const define = (options) => {
+	const { name } = options;
+	const Envelope = Schema.Struct({
+		host: Schema.Literal(name),
+		conversation: Schema.String,
+		opening: options.opening
+	});
+	const encode = Schema.encodeSync(Envelope);
+	const decode = Schema.decodeUnknownOption(Envelope);
+	const lockOf = (conversation) => `foldkit-shared-host:${name}:${conversation}`;
+	const marker = `foldkit-shared-host:${name}`;
+	const receive = (host, data, port) => Option.match(Option.zipWith(decode(data), Option.fromUndefinedOr(port), (envelope, given) => ({
+		envelope,
+		given
+	})), {
+		onNone: () => {},
+		onSome: ({ envelope, given }) => {
+			const ended = new AbortController();
+			Option.match(locks(), {
+				onNone: () => {},
+				onSome: (held) => {
+					held.request(lockOf(envelope.conversation), () => ended.abort());
+				}
+			});
+			host().then((started) => started(envelope.opening, {
+				port: given,
+				signal: ended.signal
+			})).catch(reportError);
+		}
+	});
+	const once = (start) => {
+		let started;
+		return () => started ??= Promise.resolve().then(start);
+	};
+	const serve = (start) => {
+		const host = once(start);
+		self.addEventListener("connect", (event) => {
+			if (!(event instanceof MessageEvent)) return;
+			const [connection] = event.ports;
+			connection?.addEventListener("message", (message) => receive(host, message.data, message.ports[0]));
+			connection?.start();
+		});
+	};
+	const connect = ({ worker, inPage }) => {
+		const send = routeOf(worker, inPage);
+		return { open: (opening) => {
+			const { port1, port2 } = new MessageChannel();
+			const conversation = crypto.randomUUID();
+			const envelope = encode({
+				host: name,
+				conversation,
+				opening
+			});
+			hold(lockOf(conversation)).then(() => send(envelope, port2));
+			return port1;
+		} };
+	};
+	const routeOf = (worker, inPage) => {
+		if (typeof SharedWorker !== "undefined") {
+			const { port } = worker();
+			return (envelope, given) => port.postMessage(envelope, [given]);
+		}
+		return Option.match(acceptingTop(marker), {
+			onSome: (top) => (envelope, given) => top.postMessage(envelope, location.origin, [given]),
+			onNone: () => {
+				const host = once(inPage);
+				Reflect.set(window, marker, true);
+				window.addEventListener("message", (event) => {
+					if (event.origin === location.origin) receive(host, event.data, event.ports[0]);
+				});
+				return (envelope, given) => receive(host, envelope, given);
+			}
+		});
+	};
+	return {
+		name,
+		serve,
+		connect
+	};
+};
+/** The top document, when it is another of this origin's and runs this host. */
+const acceptingTop = (marker) => {
+	const top = window.top;
+	if (top === null || top === window) return Option.none();
+	try {
+		return Reflect.get(top, marker) === true ? Option.some(top) : Option.none();
+	} catch {
+		return Option.none();
+	}
+};
+/** Resolves once this document holds `lock`, which it then holds while it lives. */
+const hold = (lock) => Option.match(locks(), {
+	onNone: () => Promise.resolve(),
+	onSome: (held) => new Promise((granted) => {
+		held.request(lock, () => {
+			granted();
+			return new Promise(() => {});
+		});
+	})
+});
+/** Web Locks, which a page outside a secure context, or an older browser, lacks. */
+const locks = () => Option.fromUndefinedOr(navigator.locks);
+/**
+* One server in the browser for many documents: every tab and frame of an
+* application meets the same host. A page opens conversations, each a
+* `MessagePort` with a decoded opening that says what it is for; the host, in
+* a SharedWorker shared by every tab, or in the top document where there is no
+* SharedWorker, is handed each one with a signal that aborts when the page
+* that opened it is gone.
+*
+* It owns the host's lifetime and the routing of conversations, nothing
+* spoken over them: Sync's `portSocket` and Remote's `port` do that.
+*/
+const SharedHost = { define };
+export { SharedHost };
+
+//# sourceMappingURL=sharedHost.js.map

package/dist/net/sharedHost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharedHost.js","names":[],"sources":["../../src/net/sharedHost.ts"],"sourcesContent":["import { Option, Schema } from 'effect'\n\n/** One conversation a page opened: its port, and a signal that aborts once the page is gone. */\nexport interface Conversation {\n  readonly port: MessagePort\n  readonly signal: AbortSignal\n}\n\n/** What the host does with each conversation, told what the page opened it for. */\nexport type ConversationHandler<Opening> = (opening: Opening, conversation: Conversation) => void\n\n/** Starts the host, once, the first time a conversation needs it. */\nexport type StartHost<Opening> = () =>\n  | ConversationHandler<Opening>\n  | Promise<ConversationHandler<Opening>>\n\n/** Where `SharedHost` runs the host: in a SharedWorker, or in the page when there is none. */\nexport interface SharedHostOptions<Opening> {\n  /**\n   * The SharedWorker whose entry calls `serve`. Constructed by the\n   * application, since a bundler finds a worker only in a literal\n   * `new SharedWorker(new URL('./worker.ts', import.meta.url), …)`.\n   */\n  readonly worker: () => { readonly port: MessagePort }\n  /** The host, for a browser without SharedWorker: started in the top document. */\n  readonly inPage: StartHost<Opening>\n}\n\n/** A page's way to the host. */\nexport interface SharedHostConnection<Opening> {\n  /** Opens a conversation for `opening`, returning the page's end of it. */\n  readonly open: (opening: Opening) => MessagePort\n}\n\nexport interface SharedHost<Opening> {\n  readonly name: string\n  /** A SharedWorker's entry: hands the host every conversation a page opens. */\n  readonly serve: (start: StartHost<Opening>) => void\n  /**\n   * A page's connection: through the SharedWorker, or, without one, to the\n   * host in the top document. Call it in the top document too when that\n   * document frames the pages, so that it is the one the frames meet.\n   */\n  readonly connect: (options: SharedHostOptions<Opening>) => SharedHostConnection<Opening>\n}\n\n/**\n * A shared host: its `name`, which keeps two on one origin apart, and\n * the schema of what opens a conversation, which the host decodes before\n * anything else, ignoring a message that does not decode.\n */\nconst define = <Opening, Encoded>(options: {\n  readonly name: string\n  readonly opening: Schema.Codec<Opening, Encoded, never, never>\n}): SharedHost<Opening> => {\n  const { name } = options\n  const Envelope = Schema.Struct({\n    host: Schema.Literal(name),\n    conversation: Schema.String,\n    opening: options.opening,\n  })\n  const encode = Schema.encodeSync(Envelope)\n  const decode = Schema.decodeUnknownOption(Envelope)\n  const lockOf = (conversation: string) => `foldkit-shared-host:${name}:${conversation}`\n  const marker = `foldkit-shared-host:${name}`\n\n  const receive = (\n    host: () => Promise<ConversationHandler<Opening>>,\n    data: unknown,\n    port: MessagePort | undefined,\n  ) =>\n    Option.match(\n      Option.zipWith(decode(data), Option.fromUndefinedOr(port), (envelope, given) => ({\n        envelope,\n        given,\n      })),\n      {\n        // Not a page's opening, or one without its port: nothing to answer.\n        onNone: () => {},\n        onSome: ({ envelope, given }) => {\n          const ended = new AbortController()\n          // The page holds this lock while it lives, so the host is granted it\n          // when the page's document unloads or crashes.\n          Option.match(locks(), {\n            onNone: () => {},\n            onSome: held => {\n              void held.request(lockOf(envelope.conversation), () => ended.abort())\n            },\n          })\n          void host()\n            .then(started => started(envelope.opening, { port: given, signal: ended.signal }))\n            .catch(reportError)\n        },\n      },\n    )\n\n  const once = (start: StartHost<Opening>): (() => Promise<ConversationHandler<Opening>>) => {\n    let started: Promise<ConversationHandler<Opening>> | undefined\n    return () => (started ??= Promise.resolve().then(start))\n  }\n\n  const serve = (start: StartHost<Opening>): void => {\n    const host = once(start)\n    self.addEventListener('connect', event => {\n      if (!(event instanceof MessageEvent)) return\n      const [connection] = event.ports\n      connection?.addEventListener('message', message =>\n        receive(host, message.data, message.ports[0]),\n      )\n      connection?.start()\n    })\n  }\n\n  const connect = ({\n    worker,\n    inPage,\n  }: SharedHostOptions<Opening>): SharedHostConnection<Opening> => {\n    const send = routeOf(worker, inPage)\n    return {\n      open: opening => {\n        const { port1, port2 } = new MessageChannel()\n        const conversation = crypto.randomUUID()\n        const envelope = encode({ host: name, conversation, opening })\n        // The opening goes once the lock is held, so the host cannot be\n        // granted it first and end the conversation before it began.\n        void hold(lockOf(conversation)).then(() => send(envelope, port2))\n        return port1\n      },\n    }\n  }\n\n  const routeOf = (\n    worker: SharedHostOptions<Opening>['worker'],\n    inPage: StartHost<Opening>,\n  ): ((envelope: unknown, port: MessagePort) => void) => {\n    if (typeof SharedWorker !== 'undefined') {\n      const { port } = worker()\n      return (envelope, given) => port.postMessage(envelope, [given])\n    }\n    return Option.match(acceptingTop(marker), {\n      onSome: top => (envelope, given) => top.postMessage(envelope, location.origin, [given]),\n      onNone: () => {\n        const host = once(inPage)\n        Reflect.set(window, marker, true)\n        window.addEventListener('message', event => {\n          if (event.origin === location.origin) receive(host, event.data, event.ports[0])\n        })\n        return (envelope, given) => receive(host, envelope, given)\n      },\n    })\n  }\n\n  return { name, serve, connect }\n}\n\n/** The top document, when it is another of this origin's and runs this host. */\nconst acceptingTop = (marker: string): Option.Option<Window> => {\n  const top = window.top\n  if (top === null || top === window) return Option.none()\n  try {\n    return Reflect.get(top, marker) === true ? Option.some(top) : Option.none()\n  } catch {\n    // Another origin's top document: reading it throws.\n    return Option.none()\n  }\n}\n\n/** Resolves once this document holds `lock`, which it then holds while it lives. */\nconst hold = (lock: string): Promise<void> =>\n  Option.match(locks(), {\n    onNone: () => Promise.resolve(),\n    onSome: held =>\n      new Promise(granted => {\n        void held.request(lock, () => {\n          granted()\n          return new Promise(() => {})\n        })\n      }),\n  })\n\n/** Web Locks, which a page outside a secure context, or an older browser, lacks. */\nconst locks = (): Option.Option<LockManager> => Option.fromUndefinedOr(navigator.locks)\n\n/**\n * One server in the browser for many documents: every tab and frame of an\n * application meets the same host. A page opens conversations, each a\n * `MessagePort` with a decoded opening that says what it is for; the host, in\n * a SharedWorker shared by every tab, or in the top document where there is no\n * SharedWorker, is handed each one with a signal that aborts when the page\n * that opened it is gone.\n *\n * It owns the host's lifetime and the routing of conversations, nothing\n * spoken over them: Sync's `portSocket` and Remote's `port` do that.\n */\nexport const SharedHost = { define }\n"],"mappings":"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"}

package/dist/net/sse.d.ts

@@ -0,0 +1,115 @@
+import { Option, Queue, Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+import * as ManagedResource from "foldkit/managedResource";
+/** The slice of an EventSource the bundle needs; satisfied by the platform class. */
+export interface SourceHandle {
+  readonly readyState: number;
+  close(): void;
+  onopen: ((event: any) => void) | null;
+  onmessage: ((event: any) => void) | null;
+  onerror: ((event: any) => void) | null;
+}
+export declare const SseModel: Schema.Struct<{
+  readonly url: Schema.String;
+  readonly status: Schema.Literals<readonly ["closed", "connecting", "open"]>;
+  readonly lastError: Schema.OptionFromNullOr<Schema.String>;
+}>;
+export type SseModel = typeof SseModel.Type;
+export declare const SseMessage: import("foldkit/message").MessageUnion<{
+  readonly Connecting: {};
+  readonly Opened: {};
+  /** Notifies without storing: project the payload into your own field to keep it. */
+  readonly Received: {
+    data: Schema.String;
+  };
+  readonly Closed: {};
+  readonly Failed: {
+    message: Schema.String;
+  };
+}>;
+export type SseMessage = typeof SseMessage.Type;
+/**
+ * What the reader sees: the stream's state, or its error. A page derives
+ * this instead of keeping its own connection state machine. `lastError`
+ * carries the stored failure text: the runtime error sentence (`event stream
+ * error for …`) or the acquire error's own message.
+ */
+export declare const SseView: import("foldkit/schema").TaggedUnion<{
+  readonly Disconnected: {};
+  readonly Connecting: {};
+  readonly Connected: {};
+  readonly Error: {
+    error: Schema.String;
+  };
+}>;
+export type SseView = typeof SseView.Type;
+/**
+ * Whether the stream is live: open with no error outstanding. The browser
+ * reconnects a dropped stream itself; a `Failed` only records the error.
+ */
+export declare const isLive: (model: SseModel) => boolean;
+/**
+ * The view of a stream, and whether its page still wants it. An error stands
+ * until the page stops wanting the stream; a retry still waiting for its
+ * stream reads as connecting, so it answers at once.
+ */
+export declare const viewOfSse: (model: SseModel, wanted: boolean) => SseView;
+/** The registry value behind the source tag: the live source and its incoming queue. */
+export interface AcquiredSource {
+  readonly source: SourceHandle;
+  readonly events: Queue.Queue<SseMessage>;
+}
+/** The live stream, for the incoming subscription. One assembly holds one. */
+export declare const Source: ManagedResource.ManagedResource<AcquiredSource, ManagedResource.ManagedResourceService<"sse">>;
+/** The source service a placed SSE stream requires. */
+export type SourceService = ManagedResource.ServiceOf<typeof Source>;
+/**
+ * Server-sent events as a bundle: connection lifecycle in the Model, the
+ * event stream through one Managed Resource. One-directional, so there is no
+ * send: the server speaks, the Model listens. The browser reconnects dropped
+ * streams itself; a Failed only records the error.
+ */
+export declare const sse: <const Name extends string>(config: {
+  readonly name: Name;
+  /** Defaults to the platform EventSource, read lazily so tests can substitute a double. */
+  readonly createSource?: ((url: string) => SourceHandle) | undefined;
+}) => Bundle.Bundle<Name, {
+  readonly url: string;
+}, {
+  readonly url: string;
+  readonly status: "closed" | "connecting" | "open";
+  readonly lastError: Option.Option<string>;
+}, {
+  readonly _tag: "Connecting";
+} | {
+  readonly _tag: "Closed";
+} | {
+  readonly _tag: "Failed";
+  readonly message: string;
+} | {
+  readonly _tag: "Opened";
+} | {
+  readonly _tag: "Received";
+  readonly data: string;
+}, never, ManagedResource.ManagedResourceService<"sse">, ManagedResource.ManagedResourceService<"sse">, void, {
+  source: ManagedResource.Entry<{
+    readonly url: string;
+    readonly status: "closed" | "connecting" | "open";
+    readonly lastError: Option.Option<string>;
+  }, {
+    readonly _tag: "Connecting";
+  } | {
+    readonly _tag: "Closed";
+  } | {
+    readonly _tag: "Failed";
+    readonly message: string;
+  } | {
+    readonly _tag: "Opened";
+  } | {
+    readonly _tag: "Received";
+    readonly data: string;
+  }, Option.Option<string>, AcquiredSource, ManagedResource.ManagedResourceService<"sse">, () => {
+    readonly _tag: "Connecting";
+  }>;
+}, {}>;
+//# sourceMappingURL=sse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","names":[],"sources":["../../src/net/sse.ts"],"mappings":";;;;iBAUiB;WACN;EACT;EACA,UAAU;EACV,aAAa;EACb,WAAW;;qBAGA,UAAQ,OAAA;;;;;YAKT,kBAAkB,SAAS;qBAE1B,sCAAU;;;;;IAIT,MAAI,OAAA;;;;IAEN,SAAO,OAAA;;;YAEP,oBAAoB,WAAW;;;;;;;qBAQ9B,kCAAO;;;;;IAIT,OAAK,OAAA;;;YAEJ,iBAAiB,QAAQ;;;;;qBAMxB,SAAM,OAAW;;;;;;qBAQjB,YAAS,OAAW,UAAQ,oBAAoB;;iBAY5C;WACN,QAAQ;WACR,QAAQ,MAAM,MAAM;;;qBAIlB,QAAM,gBAAA,gBAAA,gBAAA,gBAAA;;YAGP,gBAAgB,gBAAgB,iBAAiB;;;;;;;qBAWhD,YAAa,qBAAmB;WAClC,MAAM;;WAEN,iBAAiB,gBAAgB;MAC3C,OAAA,OAAA"}

package/dist/net/sse.js

@@ -0,0 +1,138 @@
+import { Effect, Option, Queue, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+import { unlessSame } from "../internal.js";
+import * as ManagedResource from "foldkit/managedResource";
+import { defineTaggedUnion } from "foldkit/schema";
+// src/net/sse.ts
+const SseModel = Schema.Struct({
+	url: Schema.String,
+	status: Schema.Literals([
+		"closed",
+		"connecting",
+		"open"
+	]),
+	lastError: Schema.OptionFromNullOr(Schema.String)
+});
+const SseMessage = defineMessageUnion({
+	Connecting: {},
+	Opened: {},
+	/** Notifies without storing: project the payload into your own field to keep it. */
+	Received: { data: Schema.String },
+	Closed: {},
+	Failed: { message: Schema.String }
+});
+/**
+* What the reader sees: the stream's state, or its error. A page derives
+* this instead of keeping its own connection state machine. `lastError`
+* carries the stored failure text: the runtime error sentence (`event stream
+* error for …`) or the acquire error's own message.
+*/
+const SseView = defineTaggedUnion({
+	Disconnected: {},
+	Connecting: {},
+	Connected: {},
+	Error: { error: Schema.String }
+});
+/**
+* Whether the stream is live: open with no error outstanding. The browser
+* reconnects a dropped stream itself; a `Failed` only records the error.
+*/
+const isLive = (model) => model.status === "open" && Option.isNone(model.lastError);
+/**
+* The view of a stream, and whether its page still wants it. An error stands
+* until the page stops wanting the stream; a retry still waiting for its
+* stream reads as connecting, so it answers at once.
+*/
+const viewOfSse = (model, wanted) => Option.match(model.lastError, {
+	onSome: (error) => model.status === "open" || !wanted ? SseView.Error({ error }) : SseView.Connecting(),
+	onNone: () => {
+		if (model.status === "open") return SseView.Connected();
+		if (model.status === "connecting" || wanted) return SseView.Connecting();
+		return SseView.Disconnected();
+	}
+});
+/** The live stream, for the incoming subscription. One assembly holds one. */
+const Source = ManagedResource.tag()("sse");
+const failMessage = (error) => error instanceof Error ? error.message : String(error);
+/**
+* Server-sent events as a bundle: connection lifecycle in the Model, the
+* event stream through one Managed Resource. One-directional, so there is no
+* send: the server speaks, the Model listens. The browser reconnects dropped
+* streams itself; a Failed only records the error.
+*/
+const sse = (config) => {
+	const createSource = config.createSource ?? ((url) => new EventSource(url));
+	return Bundle.make(config.name, {
+		Model: SseModel,
+		Message: SseMessage,
+		args: Schema.Struct({ url: Schema.String }),
+		init: (args) => ({ model: {
+			url: args.url,
+			status: "closed",
+			lastError: Option.none()
+		} }),
+		update: (model, message) => SseMessage.match(message, {
+			Connecting: () => ({ model: unlessSame(model, {
+				...model,
+				status: "connecting"
+			}) }),
+			Opened: () => ({ model: unlessSame(model, {
+				...model,
+				status: "open",
+				lastError: Option.none()
+			}) }),
+			Received: () => ({ model }),
+			Closed: () => ({ model: unlessSame(model, {
+				...model,
+				status: "closed"
+			}) }),
+			Failed: ({ message }) => ({ model: unlessSame(model, {
+				...model,
+				status: "connecting",
+				lastError: Option.some(message)
+			}) })
+		}),
+		resources: () => ManagedResource.make()((entry) => ({ source: entry(Schema.Option(Schema.String), {
+			resource: Source,
+			modelToMaybeRequirements: (model) => Option.some(model.url),
+			acquire: (url) => Effect.gen(function* () {
+				const events = yield* Queue.unbounded();
+				const source = createSource(url);
+				let tail = Promise.resolve();
+				const enqueue = (effect) => {
+					const run = () => Effect.runPromise(effect).then(() => void 0, () => void 0);
+					tail = tail.then(run, run);
+				};
+				const offer = (message) => enqueue(Queue.offer(events, message));
+				source.onopen = () => offer(SseMessage.Opened());
+				source.onmessage = (event) => offer(SseMessage.Received({ data: String(event.data) }));
+				source.onerror = () => offer(SseMessage.Failed({ message: `event stream error for ${url}` }));
+				return {
+					source,
+					events
+				};
+			}),
+			onAcquired: () => SseMessage.Connecting(),
+			onReleased: () => SseMessage.Closed(),
+			onAcquireError: (error) => SseMessage.Failed({ message: failMessage(error) }),
+			release: ({ source, events }) => Effect.asVoid(Effect.andThen(Effect.sync(() => {
+				source.onopen = null;
+				source.onmessage = null;
+				source.onerror = null;
+				source.close();
+			}), Queue.shutdown(events)))
+		}) })),
+		subscriptions: () => Subscription.make()((entry) => ({ incoming: entry({ live: Schema.Boolean }, {
+			modelToDependencies: (model) => ({ live: model.status !== "closed" }),
+			dependenciesToStream: ({ live }) => !live ? Stream.empty : Stream.unwrap(Effect.matchEffect(Source.get, {
+				onFailure: () => Effect.succeed(Stream.empty),
+				onSuccess: ({ source, events }) => Effect.succeed(Stream.concat(source.readyState === 1 ? Stream.make(SseMessage.Opened()) : Stream.empty, Stream.fromQueue(events)))
+			}))
+		}) }))
+	});
+};
+export { Source, SseMessage, SseModel, SseView, isLive, sse, viewOfSse };
+
+//# sourceMappingURL=sse.js.map

package/dist/net/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","names":[],"sources":["../../src/net/sse.ts"],"sourcesContent":["import { Effect, Option, Queue, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport { defineTaggedUnion } from 'foldkit/schema'\nimport * as ManagedResource from 'foldkit/managedResource'\nimport * as Subscription from 'foldkit/subscription'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\nimport { unlessSame } from '../internal.js'\n\n/** The slice of an EventSource the bundle needs; satisfied by the platform class. */\nexport interface SourceHandle {\n  readonly readyState: number\n  close(): void\n  onopen: ((event: any) => void) | null\n  onmessage: ((event: any) => void) | null\n  onerror: ((event: any) => void) | null\n}\n\nexport const SseModel = Schema.Struct({\n  url: Schema.String,\n  status: Schema.Literals(['closed', 'connecting', 'open']),\n  lastError: Schema.OptionFromNullOr(Schema.String),\n})\nexport type SseModel = typeof SseModel.Type\n\nexport const SseMessage = defineMessageUnion({\n  Connecting: {},\n  Opened: {},\n  /** Notifies without storing: project the payload into your own field to keep it. */\n  Received: { data: Schema.String },\n  Closed: {},\n  Failed: { message: Schema.String },\n})\nexport type SseMessage = typeof SseMessage.Type\n\n/**\n * What the reader sees: the stream's state, or its error. A page derives\n * this instead of keeping its own connection state machine. `lastError`\n * carries the stored failure text: the runtime error sentence (`event stream\n * error for …`) or the acquire error's own message.\n */\nexport const SseView = defineTaggedUnion({\n  Disconnected: {},\n  Connecting: {},\n  Connected: {},\n  Error: { error: Schema.String },\n})\nexport type SseView = typeof SseView.Type\n\n/**\n * Whether the stream is live: open with no error outstanding. The browser\n * reconnects a dropped stream itself; a `Failed` only records the error.\n */\nexport const isLive = (model: SseModel): boolean =>\n  model.status === 'open' && Option.isNone(model.lastError)\n\n/**\n * The view of a stream, and whether its page still wants it. An error stands\n * until the page stops wanting the stream; a retry still waiting for its\n * stream reads as connecting, so it answers at once.\n */\nexport const viewOfSse = (model: SseModel, wanted: boolean): SseView =>\n  Option.match(model.lastError, {\n    onSome: error =>\n      model.status === 'open' || !wanted ? SseView.Error({ error }) : SseView.Connecting(),\n    onNone: () => {\n      if (model.status === 'open') return SseView.Connected()\n      if (model.status === 'connecting' || wanted) return SseView.Connecting()\n      return SseView.Disconnected()\n    },\n  })\n\n/** The registry value behind the source tag: the live source and its incoming queue. */\nexport interface AcquiredSource {\n  readonly source: SourceHandle\n  readonly events: Queue.Queue<SseMessage>\n}\n\n/** The live stream, for the incoming subscription. One assembly holds one. */\nexport const Source = ManagedResource.tag<AcquiredSource>()('sse')\n\n/** The source service a placed SSE stream requires. */\nexport type SourceService = ManagedResource.ServiceOf<typeof Source>\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\n/**\n * Server-sent events as a bundle: connection lifecycle in the Model, the\n * event stream through one Managed Resource. One-directional, so there is no\n * send: the server speaks, the Model listens. The browser reconnects dropped\n * streams itself; a Failed only records the error.\n */\nexport const sse = <const Name extends string>(config: {\n  readonly name: Name\n  /** Defaults to the platform EventSource, read lazily so tests can substitute a double. */\n  readonly createSource?: ((url: string) => SourceHandle) | undefined\n}) => {\n  const createSource: (url: string) => SourceHandle =\n    config.createSource ?? (url => new EventSource(url) as unknown as SourceHandle)\n  return Bundle.make(config.name, {\n    Model: SseModel,\n    Message: SseMessage,\n    args: Schema.Struct({ url: Schema.String }),\n    init: (args): Update.Return<SseModel, SseMessage, SourceService> => ({\n      model: { url: args.url, status: 'closed', lastError: Option.none() },\n    }),\n    update: (\n      model,\n      message,\n    ): Update.ReturnWithOutMessage<SseModel, SseMessage, never, SourceService> =>\n      SseMessage.match(message, {\n        Connecting: () => ({ model: unlessSame(model, { ...model, status: 'connecting' }) }),\n        Opened: () => ({\n          model: unlessSame(model, { ...model, status: 'open', lastError: Option.none() }),\n        }),\n        Received: () => ({ model }),\n        Closed: () => ({ model: unlessSame(model, { ...model, status: 'closed' }) }),\n        // EventSource retries on its own, erroring the same way on every attempt.\n        Failed: ({ message }) => ({\n          model: unlessSame(model, {\n            ...model,\n            status: 'connecting',\n            lastError: Option.some(message),\n          }),\n        }),\n      }),\n    resources: () =>\n      ManagedResource.make<SseModel, SseMessage>()(entry => ({\n        source: entry(Schema.Option(Schema.String), {\n          resource: Source,\n          modelToMaybeRequirements: model => Option.some(model.url),\n          acquire: (url: string) =>\n            Effect.gen(function* () {\n              const events = yield* Queue.unbounded<SseMessage>()\n              const source = createSource(url)\n              // Offers run in arrival order; see the WebSocket bundle.\n              let tail: Promise<void> = Promise.resolve()\n              const enqueue = (effect: Effect.Effect<unknown>): void => {\n                const run = () =>\n                  Effect.runPromise(effect).then(\n                    () => undefined,\n                    () => undefined,\n                  )\n                tail = tail.then(run, run)\n              }\n              const offer = (message: SseMessage) => enqueue(Queue.offer(events, message))\n              source.onopen = () => offer(SseMessage.Opened())\n              // Event data is always text per the SSE spec.\n              source.onmessage = event => offer(SseMessage.Received({ data: String(event.data) }))\n              source.onerror = () =>\n                offer(SseMessage.Failed({ message: `event stream error for ${url}` }))\n              return { source, events }\n            }),\n          onAcquired: () => SseMessage.Connecting(),\n          onReleased: () => SseMessage.Closed(),\n          onAcquireError: error => SseMessage.Failed({ message: failMessage(error) }),\n          // Daemon teardown: close the stream and drain the queue.\n          release: ({ source, events }) =>\n            Effect.asVoid(\n              Effect.andThen(\n                Effect.sync(() => {\n                  source.onopen = null\n                  source.onmessage = null\n                  source.onerror = null\n                  source.close()\n                }),\n                Queue.shutdown(events),\n              ),\n            ),\n        }),\n      })),\n    subscriptions: (): Subscription.Subscriptions<SseModel, SseMessage, SourceService> =>\n      Subscription.make<SseModel, SseMessage, SourceService>()(entry => ({\n        incoming: entry(\n          // Connecting to open is no reason to restart: the stream reads the\n          // same queue, and replays an open it attached too late to see.\n          { live: Schema.Boolean },\n          {\n            modelToDependencies: model => ({ live: model.status !== 'closed' }),\n            dependenciesToStream: ({ live }) =>\n              !live\n                ? Stream.empty\n                : Stream.unwrap(\n                    Effect.matchEffect(Source.get, {\n                      // Released between the dependency read and attach: end\n                      // quietly; onReleased reports Closed through update.\n                      onFailure: () => Effect.succeed(Stream.empty),\n                      onSuccess: ({ source, events }) =>\n                        Effect.succeed(\n                          Stream.concat(\n                            // A fast server opens before the stream attaches.\n                            // 1 is OPEN for EventSource everywhere.\n                            source.readyState === 1\n                              ? Stream.make(SseMessage.Opened())\n                              : Stream.empty,\n                            Stream.fromQueue(events),\n                          ),\n                        ),\n                    }),\n                  ),\n          },\n        ),\n      })),\n  })\n}\n"],"mappings":"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"}