foldkit-primitives 0.15.3 → 0.16.0

package/dist/net/websocket.d.ts

@@ -0,0 +1,172 @@
+import { Effect, Option, Queue, Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+import * as ManagedResource from "foldkit/managedResource";
+/** The slice of a WebSocket the bundle needs; satisfied by the platform socket and test doubles. Handler events are `any`: the DOM and `ws` type them differently, and only `data` is read. */
+export interface SocketHandle {
+  readonly readyState: number;
+  send(data: string): void;
+  close(): void;
+  onopen: ((event: any) => void) | null;
+  onmessage: ((event: any) => void) | null;
+  onclose: ((event: any) => void) | null;
+  onerror: ((event: any) => void) | null;
+}
+export declare const WebSocketModel: Schema.Struct<{
+  readonly url: Schema.String;
+  readonly status: Schema.Literals<readonly ["closed", "connecting", "open"]>;
+  readonly lastError: Schema.OptionFromNullOr<Schema.String>;
+  /** Whether this connection attempt ever reached open; reset on Connecting. */
+  readonly opened: Schema.Boolean;
+}>;
+export type WebSocketModel = typeof WebSocketModel.Type;
+export declare const WebSocketMessage: 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;
+  };
+  readonly SendFailed: {
+    message: Schema.String;
+  };
+  /** Acknowledges dispatch of `data`, not its delivery; update ignores it. */
+  readonly Sent: {
+    data: Schema.String;
+  };
+  /** The socket was still connecting when `connectTimeoutMs` ran out, and was closed. */
+  readonly TimedOut: {};
+}>;
+export type WebSocketMessage = typeof WebSocketMessage.Type;
+/** The registry value behind the socket tag: the live socket and its incoming queue. */
+export interface Acquired {
+  readonly socket: SocketHandle;
+  readonly events: Queue.Queue<WebSocketMessage>;
+}
+/**
+ * What the reader sees: the socket's state, or its error. A page derives
+ * this instead of keeping its own connection state machine. `lastError` is
+ * already worded for the reader (`Failed to connect to WebSocket`, never the
+ * socket's own text, which error handling drops in favor of the sentence).
+ */
+export declare const SocketView: import("foldkit/schema").TaggedUnion<{
+  readonly Disconnected: {};
+  readonly Connecting: {};
+  readonly Connected: {};
+  readonly Error: {
+    error: Schema.String;
+  };
+}>;
+export type SocketView = typeof SocketView.Type;
+/**
+ * Whether the socket is usable: open with no error outstanding. Gates sends
+ * and received frames.
+ */
+export declare const isOpen: (model: WebSocketModel) => boolean;
+/**
+ * The view of a socket, and whether its page still wants it. An error stands
+ * until the page stops wanting the socket; a retry still waiting for its
+ * socket reads as connecting, so it answers at once. An error on an open
+ * socket always reads as an error.
+ */
+export declare const viewOf: (model: WebSocketModel, wanted: boolean) => SocketView;
+/** The live connection, for `send` and the incoming stream. One assembly holds one. */
+export declare const Socket: ManagedResource.ManagedResource<Acquired, ManagedResource.ManagedResourceService<"websocket">>;
+/** The socket service a placed WebSocket's streams and send commands require. */
+export type SocketService = ManagedResource.ServiceOf<typeof Socket>;
+/**
+ * A WebSocket as a bundle: connection lifecycle in the Model, full duplex
+ * through one Managed Resource. The resource owns the socket; a `send`
+ * helper writes through its tag service (lifted to the parent like every
+ * helper); a subscription stream reads incoming messages through the same
+ * tag. No hidden hub: everything the bundle touches is the Model, the
+ * resource registry, or a Message.
+ */
+export declare const websocket: <const Name extends string>(config: {
+  readonly name: Name;
+  /** Defaults to the platform WebSocket, read lazily so tests can substitute a double. */
+  readonly createSocket?: ((url: string) => SocketHandle) | undefined;
+}) => Bundle.Bundle<Name, {
+  readonly url: string;
+  readonly connectTimeoutMs?: number | undefined;
+}, {
+  readonly url: string;
+  readonly status: "closed" | "connecting" | "open";
+  readonly lastError: Option.Option<string>;
+  readonly opened: boolean;
+}, {
+  readonly _tag: "Connecting";
+} | {
+  readonly _tag: "Closed";
+} | {
+  readonly _tag: "Failed";
+  readonly message: string;
+} | {
+  readonly _tag: "Opened";
+} | {
+  readonly _tag: "Received";
+  readonly data: string;
+} | {
+  readonly _tag: "SendFailed";
+  readonly message: string;
+} | {
+  readonly _tag: "Sent";
+  readonly data: string;
+} | {
+  readonly _tag: "TimedOut";
+}, never, ManagedResource.ManagedResourceService<"websocket">, ManagedResource.ManagedResourceService<"websocket">, void, {
+  socket: ManagedResource.Entry<{
+    readonly url: string;
+    readonly status: "closed" | "connecting" | "open";
+    readonly lastError: Option.Option<string>;
+    readonly opened: boolean;
+  }, {
+    readonly _tag: "Connecting";
+  } | {
+    readonly _tag: "Closed";
+  } | {
+    readonly _tag: "Failed";
+    readonly message: string;
+  } | {
+    readonly _tag: "Opened";
+  } | {
+    readonly _tag: "Received";
+    readonly data: string;
+  } | {
+    readonly _tag: "SendFailed";
+    readonly message: string;
+  } | {
+    readonly _tag: "Sent";
+    readonly data: string;
+  } | {
+    readonly _tag: "TimedOut";
+  }, Option.Option<string>, Acquired, ManagedResource.ManagedResourceService<"websocket">, () => {
+    readonly _tag: "Connecting";
+  }>;
+}, {
+  send: (model: WebSocketModel, data: string) => {
+    model: {
+      readonly url: string;
+      readonly status: "closed" | "connecting" | "open";
+      readonly lastError: Option.Option<string>;
+      readonly opened: boolean;
+    };
+    commands: {
+      name: string;
+      args: {
+        data: string;
+      };
+      effect: Effect.Effect<{
+        readonly _tag: "Sent";
+        readonly data: string;
+      } | {
+        readonly _tag: "SendFailed";
+        readonly message: string;
+      }, never, ManagedResource.ManagedResourceService<"websocket">>;
+    }[];
+  };
+}>;
+//# sourceMappingURL=websocket.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","names":[],"sources":["../../src/net/websocket.ts"],"mappings":";;;;iBAUiB;WACN;EACT,KAAK;EACL;EACA,UAAU;EACV,aAAa;EACb,WAAW;EACX,WAAW;;qBAGA,gBAAc,OAAA;;;;;;;YAOf,wBAAwB,eAAe;qBAEtC,4CAAgB;;;;;IAIf,MAAI,OAAA;;;;IAEN,SAAO,OAAA;;;IACH,SAAO,OAAA;;;;IAEb,MAAI,OAAA;;;;;YAIF,0BAA0B,iBAAiB;;iBAGtC;WACN,QAAQ;WACR,QAAQ,MAAM,MAAM;;;;;;;;qBASlB,qCAAU;;;;;IAIZ,OAAK,OAAA;;;YAEJ,oBAAoB,WAAW;;;;;qBAM9B,SAAM,OAAW;;;;;;;qBASjB,SAAM,OAAW,gBAAc,oBAAoB;;qBAYnD,QAAM,gBAAA,gBAAA,UAAA,gBAAA;;YAGP,gBAAgB,gBAAgB,iBAAiB;;;;;;;;;qBA+BhD,kBAAmB,qBAAmB;WACxC,MAAM;;WAEN,iBAAiB,gBAAgB;MAC3C,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2KmB,OAAA,OAAA,gBAAc"}

package/dist/net/websocket.js

@@ -0,0 +1,199 @@
+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/websocket.ts
+const WebSocketModel = Schema.Struct({
+	url: Schema.String,
+	status: Schema.Literals([
+		"closed",
+		"connecting",
+		"open"
+	]),
+	lastError: Schema.OptionFromNullOr(Schema.String),
+	/** Whether this connection attempt ever reached open; reset on Connecting. */
+	opened: Schema.Boolean
+});
+const WebSocketMessage = 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 },
+	SendFailed: { message: Schema.String },
+	/** Acknowledges dispatch of `data`, not its delivery; update ignores it. */
+	Sent: { data: Schema.String },
+	/** The socket was still connecting when `connectTimeoutMs` ran out, and was closed. */
+	TimedOut: {}
+});
+/**
+* What the reader sees: the socket's state, or its error. A page derives
+* this instead of keeping its own connection state machine. `lastError` is
+* already worded for the reader (`Failed to connect to WebSocket`, never the
+* socket's own text, which error handling drops in favor of the sentence).
+*/
+const SocketView = defineTaggedUnion({
+	Disconnected: {},
+	Connecting: {},
+	Connected: {},
+	Error: { error: Schema.String }
+});
+/**
+* Whether the socket is usable: open with no error outstanding. Gates sends
+* and received frames.
+*/
+const isOpen = (model) => model.status === "open" && Option.isNone(model.lastError);
+/**
+* The view of a socket, and whether its page still wants it. An error stands
+* until the page stops wanting the socket; a retry still waiting for its
+* socket reads as connecting, so it answers at once. An error on an open
+* socket always reads as an error.
+*/
+const viewOf = (model, wanted) => Option.match(model.lastError, {
+	onSome: (error) => model.status === "open" || !wanted ? SocketView.Error({ error }) : SocketView.Connecting(),
+	onNone: () => {
+		if (model.status === "open") return SocketView.Connected();
+		if (model.status === "connecting" || wanted) return SocketView.Connecting();
+		return SocketView.Disconnected();
+	}
+});
+/** The live connection, for `send` and the incoming stream. One assembly holds one. */
+const Socket = ManagedResource.tag()("websocket");
+const textOf = (data) => typeof data === "string" ? Effect.succeed(data) : data instanceof Blob ? Effect.promise(() => data.text()) : data instanceof ArrayBuffer || ArrayBuffer.isView(data) ? Effect.succeed(new TextDecoder().decode(data)) : Effect.succeed(String(data));
+/** Closes the socket with its handlers detached first, so the close reports nothing. */
+const closeSilently = (socket) => {
+	socket.onopen = null;
+	socket.onmessage = null;
+	socket.onclose = null;
+	socket.onerror = null;
+	socket.close();
+};
+const failMessage = (error) => error instanceof Error ? error.message : String(error);
+/**
+* A WebSocket as a bundle: connection lifecycle in the Model, full duplex
+* through one Managed Resource. The resource owns the socket; a `send`
+* helper writes through its tag service (lifted to the parent like every
+* helper); a subscription stream reads incoming messages through the same
+* tag. No hidden hub: everything the bundle touches is the Model, the
+* resource registry, or a Message.
+*/
+const websocket = (config) => {
+	const createSocket = config.createSocket ?? ((url) => new WebSocket(url));
+	return Bundle.make(config.name, {
+		Model: WebSocketModel,
+		Message: WebSocketMessage,
+		args: Schema.Struct({
+			url: Schema.String,
+			/** How long a socket may stay connecting before it is closed as `TimedOut`; unbounded when absent. */
+			connectTimeoutMs: Schema.optional(Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())))
+		}),
+		init: (args) => ({ model: {
+			url: args.url,
+			status: "closed",
+			lastError: Option.none(),
+			opened: false
+		} }),
+		update: (model, message) => WebSocketMessage.match(message, {
+			Connecting: () => ({ model: unlessSame(model, {
+				...model,
+				status: "connecting",
+				lastError: Option.none(),
+				opened: false
+			}) }),
+			Opened: () => ({ model: unlessSame(model, {
+				...model,
+				status: "open",
+				lastError: Option.none(),
+				opened: true
+			}) }),
+			Received: () => ({ model }),
+			Closed: () => ({ model: unlessSame(model, {
+				...model,
+				status: "closed"
+			}) }),
+			Failed: () => ({ model: unlessSame(model, {
+				...model,
+				status: "closed",
+				lastError: Option.some(model.status === "open" ? "Connection error" : "Failed to connect to WebSocket")
+			}) }),
+			SendFailed: () => ({ model: unlessSame(model, {
+				...model,
+				lastError: Option.some("Socket unavailable")
+			}) }),
+			Sent: () => ({ model }),
+			TimedOut: () => ({ model: unlessSame(model, {
+				...model,
+				status: "closed",
+				lastError: Option.some("Connection timeout")
+			}) })
+		}),
+		resources: () => ManagedResource.make()((entry) => ({ socket: entry(Schema.Option(Schema.String), {
+			resource: Socket,
+			modelToMaybeRequirements: (model) => Option.some(model.url),
+			acquire: (url) => Effect.gen(function* () {
+				const events = yield* Queue.unbounded();
+				const socket = createSocket(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));
+				socket.onopen = () => offer(WebSocketMessage.Opened());
+				socket.onmessage = (event) => {
+					enqueue(Effect.flatMap(textOf(event.data), (text) => Queue.offer(events, WebSocketMessage.Received({ data: text }))));
+				};
+				socket.onclose = () => offer(WebSocketMessage.Closed());
+				socket.onerror = () => offer(WebSocketMessage.Failed({ message: `websocket error for ${url}` }));
+				return {
+					socket,
+					events
+				};
+			}),
+			onAcquired: () => WebSocketMessage.Connecting(),
+			onReleased: () => WebSocketMessage.Closed(),
+			onAcquireError: (error) => WebSocketMessage.Failed({ message: failMessage(error) }),
+			release: ({ socket, events }) => Effect.asVoid(Effect.andThen(Effect.sync(() => closeSilently(socket)), Queue.shutdown(events)))
+		}) })),
+		subscriptions: ({ connectTimeoutMs }) => Subscription.make()((entry) => ({
+			connectTimeout: entry({ connecting: Schema.Boolean }, {
+				modelToDependencies: (model) => ({ connecting: model.status === "connecting" }),
+				dependenciesToStream: ({ connecting }) => !connecting || connectTimeoutMs === void 0 ? Stream.empty : Stream.unwrap(Effect.matchEffect(Effect.andThen(Effect.sleep(connectTimeoutMs), Socket.get), {
+					onFailure: () => Effect.succeed(Stream.empty),
+					onSuccess: ({ socket }) => Effect.sync(() => {
+						if (socket.readyState !== 0) return Stream.empty;
+						closeSilently(socket);
+						return Stream.make(WebSocketMessage.TimedOut());
+					})
+				}))
+			}),
+			incoming: entry({ live: Schema.Boolean }, {
+				modelToDependencies: (model) => ({ live: model.status !== "closed" }),
+				dependenciesToStream: ({ live }) => !live ? Stream.empty : Stream.unwrap(Effect.matchEffect(Socket.get, {
+					onFailure: () => Effect.succeed(Stream.empty),
+					onSuccess: ({ socket, events }) => Effect.succeed(Stream.concat(socket.readyState === 1 ? Stream.make(WebSocketMessage.Opened()) : Stream.empty, Stream.fromQueue(events)))
+				}))
+			})
+		})),
+		helpers: { send: (model, data) => ({
+			model,
+			commands: [{
+				name: "WebSocket.send",
+				args: { data },
+				effect: Effect.matchEffect(Effect.flatMap(Socket.get, ({ socket }) => socket.readyState === 1 ? Effect.map(Effect.sync(() => {
+					socket.send(data);
+				}), () => WebSocketMessage.Sent({ data })) : Effect.fail(/* @__PURE__ */ new Error(`cannot send: socket is not open (readyState ${socket.readyState})`))), {
+					onFailure: (error) => Effect.succeed(WebSocketMessage.SendFailed({ message: failMessage(error) })),
+					onSuccess: (message) => Effect.succeed(message)
+				})
+			}]
+		}) }
+	});
+};
+export { Socket, SocketView, WebSocketMessage, WebSocketModel, isOpen, viewOf, websocket };
+
+//# sourceMappingURL=websocket.js.map

package/dist/net/websocket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.js","names":[],"sources":["../../src/net/websocket.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 a WebSocket the bundle needs; satisfied by the platform socket and test doubles. Handler events are `any`: the DOM and `ws` type them differently, and only `data` is read. */\nexport interface SocketHandle {\n  readonly readyState: number\n  send(data: string): void\n  close(): void\n  onopen: ((event: any) => void) | null\n  onmessage: ((event: any) => void) | null\n  onclose: ((event: any) => void) | null\n  onerror: ((event: any) => void) | null\n}\n\nexport const WebSocketModel = Schema.Struct({\n  url: Schema.String,\n  status: Schema.Literals(['closed', 'connecting', 'open']),\n  lastError: Schema.OptionFromNullOr(Schema.String),\n  /** Whether this connection attempt ever reached open; reset on Connecting. */\n  opened: Schema.Boolean,\n})\nexport type WebSocketModel = typeof WebSocketModel.Type\n\nexport const WebSocketMessage = 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  SendFailed: { message: Schema.String },\n  /** Acknowledges dispatch of `data`, not its delivery; update ignores it. */\n  Sent: { data: Schema.String },\n  /** The socket was still connecting when `connectTimeoutMs` ran out, and was closed. */\n  TimedOut: {},\n})\nexport type WebSocketMessage = typeof WebSocketMessage.Type\n\n/** The registry value behind the socket tag: the live socket and its incoming queue. */\nexport interface Acquired {\n  readonly socket: SocketHandle\n  readonly events: Queue.Queue<WebSocketMessage>\n}\n\n/**\n * What the reader sees: the socket's state, or its error. A page derives\n * this instead of keeping its own connection state machine. `lastError` is\n * already worded for the reader (`Failed to connect to WebSocket`, never the\n * socket's own text, which error handling drops in favor of the sentence).\n */\nexport const SocketView = defineTaggedUnion({\n  Disconnected: {},\n  Connecting: {},\n  Connected: {},\n  Error: { error: Schema.String },\n})\nexport type SocketView = typeof SocketView.Type\n\n/**\n * Whether the socket is usable: open with no error outstanding. Gates sends\n * and received frames.\n */\nexport const isOpen = (model: WebSocketModel): boolean =>\n  model.status === 'open' && Option.isNone(model.lastError)\n\n/**\n * The view of a socket, and whether its page still wants it. An error stands\n * until the page stops wanting the socket; a retry still waiting for its\n * socket reads as connecting, so it answers at once. An error on an open\n * socket always reads as an error.\n */\nexport const viewOf = (model: WebSocketModel, wanted: boolean): SocketView =>\n  Option.match(model.lastError, {\n    onSome: error =>\n      model.status === 'open' || !wanted ? SocketView.Error({ error }) : SocketView.Connecting(),\n    onNone: () => {\n      if (model.status === 'open') return SocketView.Connected()\n      if (model.status === 'connecting' || wanted) return SocketView.Connecting()\n      return SocketView.Disconnected()\n    },\n  })\n\n/** The live connection, for `send` and the incoming stream. One assembly holds one. */\nexport const Socket = ManagedResource.tag<Acquired>()('websocket')\n\n/** The socket service a placed WebSocket's streams and send commands require. */\nexport type SocketService = ManagedResource.ServiceOf<typeof Socket>\n\nconst textOf = (data: unknown): Effect.Effect<string> =>\n  typeof data === 'string'\n    ? Effect.succeed(data)\n    : data instanceof Blob\n      ? Effect.promise(() => data.text())\n      : data instanceof ArrayBuffer || ArrayBuffer.isView(data)\n        ? Effect.succeed(new TextDecoder().decode(data))\n        : Effect.succeed(String(data))\n\n/** Closes the socket with its handlers detached first, so the close reports nothing. */\nconst closeSilently = (socket: SocketHandle): void => {\n  socket.onopen = null\n  socket.onmessage = null\n  socket.onclose = null\n  socket.onerror = null\n  socket.close()\n}\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\n/**\n * A WebSocket as a bundle: connection lifecycle in the Model, full duplex\n * through one Managed Resource. The resource owns the socket; a `send`\n * helper writes through its tag service (lifted to the parent like every\n * helper); a subscription stream reads incoming messages through the same\n * tag. No hidden hub: everything the bundle touches is the Model, the\n * resource registry, or a Message.\n */\nexport const websocket = <const Name extends string>(config: {\n  readonly name: Name\n  /** Defaults to the platform WebSocket, read lazily so tests can substitute a double. */\n  readonly createSocket?: ((url: string) => SocketHandle) | undefined\n}) => {\n  const createSocket: (url: string) => SocketHandle =\n    config.createSocket ?? (url => new WebSocket(url) as unknown as SocketHandle)\n  return Bundle.make(config.name, {\n    Model: WebSocketModel,\n    Message: WebSocketMessage,\n    args: Schema.Struct({\n      url: Schema.String,\n      /** How long a socket may stay connecting before it is closed as `TimedOut`; unbounded when absent. */\n      connectTimeoutMs: Schema.optional(\n        Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())),\n      ),\n    }),\n    init: (args): Update.Return<WebSocketModel, WebSocketMessage, SocketService> => ({\n      model: { url: args.url, status: 'closed', lastError: Option.none(), opened: false },\n    }),\n    update: (\n      model,\n      message,\n    ): Update.ReturnWithOutMessage<WebSocketModel, WebSocketMessage, never, SocketService> =>\n      WebSocketMessage.match(message, {\n        Connecting: () => ({\n          model: unlessSame(model, {\n            ...model,\n            status: 'connecting',\n            lastError: Option.none(),\n            opened: false,\n          }),\n        }),\n        Opened: () => ({\n          model: unlessSame(model, {\n            ...model,\n            status: 'open',\n            lastError: Option.none(),\n            opened: true,\n          }),\n        }),\n        Received: () => ({ model }),\n        // The close that follows an error, and the release after it, find it closed.\n        Closed: () => ({ model: unlessSame(model, { ...model, status: 'closed' }) }),\n        // Worded by whether the socket had opened: the socket's own text is\n        // dropped in favor of the sentence, as a page would word it.\n        Failed: () => ({\n          model: unlessSame(model, {\n            ...model,\n            status: 'closed',\n            lastError: Option.some(\n              model.status === 'open' ? 'Connection error' : 'Failed to connect to WebSocket',\n            ),\n          }),\n        }),\n        SendFailed: () => ({\n          model: unlessSame(model, { ...model, lastError: Option.some('Socket unavailable') }),\n        }),\n        Sent: () => ({ model }),\n        TimedOut: () => ({\n          model: unlessSame(model, {\n            ...model,\n            status: 'closed',\n            lastError: Option.some('Connection timeout'),\n          }),\n        }),\n      }),\n    resources: () =>\n      ManagedResource.make<WebSocketModel, WebSocketMessage>()(entry => ({\n        socket: entry(Schema.Option(Schema.String), {\n          resource: Socket,\n          modelToMaybeRequirements: model => Option.some(model.url),\n          acquire: (url: string) =>\n            Effect.gen(function* () {\n              const events = yield* Queue.unbounded<WebSocketMessage>()\n              const socket = createSocket(url)\n              // Offers run in arrival order: an async decode (Blob text) must\n              // not overtake a later message. Rejections settle the chain\n              // without breaking it; shutdown races are expected at teardown.\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: WebSocketMessage) => enqueue(Queue.offer(events, message))\n              socket.onopen = () => offer(WebSocketMessage.Opened())\n              socket.onmessage = event => {\n                enqueue(\n                  Effect.flatMap(textOf(event.data), text =>\n                    Queue.offer(events, WebSocketMessage.Received({ data: text })),\n                  ),\n                )\n              }\n              socket.onclose = () => offer(WebSocketMessage.Closed())\n              socket.onerror = () =>\n                offer(WebSocketMessage.Failed({ message: `websocket error for ${url}` }))\n              return { socket, events }\n            }),\n          onAcquired: () => WebSocketMessage.Connecting(),\n          onReleased: () => WebSocketMessage.Closed(),\n          onAcquireError: error => WebSocketMessage.Failed({ message: failMessage(error) }),\n          // Daemon teardown: close the socket and drain the queue.\n          release: ({ socket, events }) =>\n            Effect.asVoid(\n              Effect.andThen(\n                Effect.sync(() => closeSilently(socket)),\n                Queue.shutdown(events),\n              ),\n            ),\n        }),\n      })),\n    subscriptions: ({\n      connectTimeoutMs,\n    }): Subscription.Subscriptions<WebSocketModel, WebSocketMessage, SocketService> =>\n      Subscription.make<WebSocketModel, WebSocketMessage, SocketService>()(entry => ({\n        connectTimeout: entry(\n          { connecting: Schema.Boolean },\n          {\n            modelToDependencies: model => ({ connecting: model.status === 'connecting' }),\n            dependenciesToStream: ({ connecting }) =>\n              !connecting || connectTimeoutMs === undefined\n                ? Stream.empty\n                : Stream.unwrap(\n                    Effect.matchEffect(Effect.andThen(Effect.sleep(connectTimeoutMs), Socket.get), {\n                      // Released while waiting: onReleased reports Closed.\n                      onFailure: () => Effect.succeed(Stream.empty),\n                      onSuccess: ({ socket }) =>\n                        Effect.sync((): Stream.Stream<WebSocketMessage> => {\n                          // 0 is WebSocket.CONNECTING. An open that beat the\n                          // timer wins; the handlers go before the close, so\n                          // the error and close it causes report nothing.\n                          if (socket.readyState !== 0) return Stream.empty\n                          closeSilently(socket)\n                          return Stream.make(WebSocketMessage.TimedOut())\n                        }),\n                    }),\n                  ),\n          },\n        ),\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(Socket.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: ({ socket, events }) =>\n                        Effect.succeed(\n                          Stream.concat(\n                            // A fast server opens before the stream attaches; without\n                            // this the status would stick at connecting while\n                            // messages flow. 1 is WebSocket.OPEN everywhere.\n                            socket.readyState === 1\n                              ? Stream.make(WebSocketMessage.Opened())\n                              : Stream.empty,\n                            Stream.fromQueue(events),\n                          ),\n                        ),\n                    }),\n                  ),\n          },\n        ),\n      })),\n    helpers: {\n      send: (model: WebSocketModel, data: string) => ({\n        model,\n        commands: [\n          {\n            name: 'WebSocket.send',\n            args: { data },\n            effect: Effect.matchEffect(\n              Effect.flatMap(Socket.get, ({ socket }) =>\n                // A closed socket's send is a silent no-op per spec (only a\n                // connecting socket throws), so check first: SendFailed either way.\n                socket.readyState === 1\n                  ? Effect.map(\n                      Effect.sync(() => {\n                        socket.send(data)\n                      }),\n                      () => WebSocketMessage.Sent({ data }),\n                    )\n                  : Effect.fail(\n                      new Error(\n                        `cannot send: socket is not open (readyState ${socket.readyState})`,\n                      ),\n                    ),\n              ),\n              {\n                onFailure: error =>\n                  Effect.succeed(WebSocketMessage.SendFailed({ message: failMessage(error) })),\n                onSuccess: message => Effect.succeed(message),\n              },\n            ),\n          },\n        ],\n      }),\n    },\n  })\n}\n"],"mappings":"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"}

package/dist/observers/bounds.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const Measured: Schema.TaggedStruct<"Measured", {
+  readonly x: Schema.Number;
+  readonly y: Schema.Number;
+  readonly width: Schema.Number;
+  readonly height: Schema.Number;
+}>;
+export type Measured = typeof Measured.Type;
+/**
+ * Element bounds as a Mount: the bounding rect re-measured on
+ * ResizeObserver, window scroll, and window resize, starting with the
+ * current rect. Without a ResizeObserver the window events still measure —
+ * position changes never needed the observer. No window (SSR) emits nothing
+ * instead of throwing.
+ */
+export declare const Bounds: Mount.MountDefinitionNoArgs<"Bounds", {
+  readonly _tag: "Measured";
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}>;
+//# sourceMappingURL=bounds.d.ts.map

package/dist/observers/bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.d.ts","names":[],"sources":["../../src/observers/bounds.ts"],"mappings":";;qBAGa,UAAQ,OAAA;;;;;;YAMT,kBAAkB,SAAS;;;;;;;;qBAc1B,QAAM,MAAA"}

package/dist/observers/bounds.js

@@ -0,0 +1,51 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/observers/bounds.ts
+const Measured = Schema.TaggedStruct("Measured", {
+	x: Schema.Number,
+	y: Schema.Number,
+	width: Schema.Number,
+	height: Schema.Number
+});
+/**
+* Element bounds as a Mount: the bounding rect re-measured on
+* ResizeObserver, window scroll, and window resize, starting with the
+* current rect. Without a ResizeObserver the window events still measure —
+* position changes never needed the observer. No window (SSR) emits nothing
+* instead of throwing.
+*/
+const Bounds = Mount.defineStream("Bounds", {
+	messages: [Measured],
+	execute: ({ element }) => Stream.callback((queue) => Effect.gen(function* () {
+		if (typeof window === "undefined") return;
+		let last = null;
+		const measure = () => {
+			const rect = element.getBoundingClientRect();
+			if (last !== null && last.x === rect.x && last.y === rect.y && last.width === rect.width && last.height === rect.height) return;
+			last = rect;
+			Queue.offerUnsafe(queue, Measured.make({
+				x: rect.x,
+				y: rect.y,
+				width: rect.width,
+				height: rect.height
+			}));
+		};
+		yield* Effect.acquireRelease(Effect.sync(() => {
+			window.addEventListener("scroll", measure, true);
+			window.addEventListener("resize", measure);
+			const Observed = globalThis.ResizeObserver;
+			if (Observed === void 0) return null;
+			const observer = new Observed(measure);
+			observer.observe(element);
+			return observer;
+		}), (observer) => Effect.sync(() => {
+			window.removeEventListener("scroll", measure, true);
+			window.removeEventListener("resize", measure);
+			observer?.disconnect();
+		}));
+		measure();
+	}))
+});
+export { Bounds, Measured };
+
+//# sourceMappingURL=bounds.js.map

package/dist/observers/bounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.js","names":[],"sources":["../../src/observers/bounds.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Measured = Schema.TaggedStruct('Measured', {\n  x: Schema.Number,\n  y: Schema.Number,\n  width: Schema.Number,\n  height: Schema.Number,\n})\nexport type Measured = typeof Measured.Type\n\ntype ObserverCtor = new (callback: () => void) => {\n  observe(element: Element): void\n  disconnect(): void\n}\n\n/**\n * Element bounds as a Mount: the bounding rect re-measured on\n * ResizeObserver, window scroll, and window resize, starting with the\n * current rect. Without a ResizeObserver the window events still measure —\n * position changes never needed the observer. No window (SSR) emits nothing\n * instead of throwing.\n */\nexport const Bounds = Mount.defineStream('Bounds', {\n  messages: [Measured],\n  execute: ({ element }) =>\n    Stream.callback<typeof Measured.Type>(queue =>\n      Effect.gen(function* () {\n        if (typeof window === 'undefined') return\n        // Every scroll anywhere measures, and mounting measures twice (the\n        // observer's first report and the call below): report only a change.\n        let last: DOMRectReadOnly | null = null\n        const measure = () => {\n          const rect = element.getBoundingClientRect()\n          if (\n            last !== null &&\n            last.x === rect.x &&\n            last.y === rect.y &&\n            last.width === rect.width &&\n            last.height === rect.height\n          ) {\n            return\n          }\n          last = rect\n          Queue.offerUnsafe(\n            queue,\n            Measured.make({ x: rect.x, y: rect.y, width: rect.width, height: rect.height }),\n          )\n        }\n        // Capture phase: container scrolls do not bubble, but every scroll\n        // descends past the window first.\n        yield* Effect.acquireRelease(\n          Effect.sync(() => {\n            window.addEventListener('scroll', measure, true)\n            window.addEventListener('resize', measure)\n            const Observed = (globalThis as { ResizeObserver?: ObserverCtor }).ResizeObserver\n            if (Observed === undefined) return null\n            const observer = new Observed(measure)\n            observer.observe(element)\n            return observer\n          }),\n          observer =>\n            Effect.sync(() => {\n              window.removeEventListener('scroll', measure, true)\n              window.removeEventListener('resize', measure)\n              observer?.disconnect()\n            }),\n        )\n        measure()\n      }),\n    ),\n})\n"],"mappings":";;;AAGA,MAAa,WAAW,OAAO,aAAa,YAAY;CACtD,GAAG,OAAO;CACV,GAAG,OAAO;CACV,OAAO,OAAO;CACd,QAAQ,OAAO;AACjB,CAAC;;;;;;;;AAeD,MAAa,SAAS,MAAM,aAAa,UAAU;CACjD,UAAU,CAAC,QAAQ;CACnB,UAAU,EAAE,cACV,OAAO,UAA+B,UACpC,OAAO,IAAI,aAAa;EACtB,IAAI,OAAO,WAAW,aAAa;EAGnC,IAAI,OAA+B;EACnC,MAAM,gBAAgB;GACpB,MAAM,OAAO,QAAQ,sBAAsB;GAC3C,IACE,SAAS,QACT,KAAK,MAAM,KAAK,KAChB,KAAK,MAAM,KAAK,KAChB,KAAK,UAAU,KAAK,SACpB,KAAK,WAAW,KAAK,QAErB;GAEF,OAAO;GACP,MAAM,YACJ,OACA,SAAS,KAAK;IAAE,GAAG,KAAK;IAAG,GAAG,KAAK;IAAG,OAAO,KAAK;IAAO,QAAQ,KAAK;GAAO,CAAC,CAChF;EACF;EAGA,OAAO,OAAO,eACZ,OAAO,WAAW;GAChB,OAAO,iBAAiB,UAAU,SAAS,IAAI;GAC/C,OAAO,iBAAiB,UAAU,OAAO;GACzC,MAAM,WAAY,WAAiD;GACnE,IAAI,aAAa,KAAA,GAAW,OAAO;GACnC,MAAM,WAAW,IAAI,SAAS,OAAO;GACrC,SAAS,QAAQ,OAAO;GACxB,OAAO;EACT,CAAC,IACD,aACE,OAAO,WAAW;GAChB,OAAO,oBAAoB,UAAU,SAAS,IAAI;GAClD,OAAO,oBAAoB,UAAU,OAAO;GAC5C,UAAU,WAAW;EACvB,CAAC,CACL;EACA,QAAQ;CACV,CAAC,CACH;AACJ,CAAC"}

package/dist/observers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./bounds.js";
+export * from "./intersection.js";
+export * from "./mutation.js";
+export * from "./resize.js";

package/dist/observers/index.js

@@ -0,0 +1,5 @@
+export * from "./bounds.js";
+export * from "./intersection.js";
+export * from "./mutation.js";
+export * from "./resize.js";
+export {};

package/dist/observers/intersection.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const IntersectionChanged: Schema.TaggedStruct<"IntersectionChanged", {
+  readonly isIntersecting: Schema.Boolean;
+  readonly ratio: Schema.Number;
+}>;
+export type IntersectionChanged = typeof IntersectionChanged.Type;
+/**
+ * Element visibility as a Mount: IntersectionObserver reports viewport
+ * crossings as Messages for the element carrying this Mount. No observer
+ * (SSR, old browser) emits nothing instead of throwing.
+ */
+export declare const Intersection: Mount.MountDefinitionNoArgs<"Intersection", {
+  readonly _tag: "IntersectionChanged";
+  readonly isIntersecting: boolean;
+  readonly ratio: number;
+}>;
+//# sourceMappingURL=intersection.d.ts.map

package/dist/observers/intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.d.ts","names":[],"sources":["../../src/observers/intersection.ts"],"mappings":";;qBAGa,qBAAmB,OAAA;;;;YAIpB,6BAA6B,oBAAoB;;;;;;qBAShD,cAAY,MAAA"}

package/dist/observers/intersection.js

@@ -0,0 +1,33 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/observers/intersection.ts
+const IntersectionChanged = Schema.TaggedStruct("IntersectionChanged", {
+	isIntersecting: Schema.Boolean,
+	ratio: Schema.Number
+});
+/**
+* Element visibility as a Mount: IntersectionObserver reports viewport
+* crossings as Messages for the element carrying this Mount. No observer
+* (SSR, old browser) emits nothing instead of throwing.
+*/
+const Intersection = Mount.defineStream("Intersection", {
+	messages: [IntersectionChanged],
+	execute: ({ element }) => Stream.callback((queue) => Effect.gen(function* () {
+		const Observed = globalThis.IntersectionObserver;
+		if (Observed === void 0) return;
+		yield* Effect.acquireRelease(Effect.sync(() => {
+			const observer = new Observed((entries) => {
+				const first = entries[0];
+				if (first !== void 0) Queue.offerUnsafe(queue, IntersectionChanged.make({
+					isIntersecting: first.isIntersecting,
+					ratio: first.intersectionRatio
+				}));
+			});
+			observer.observe(element);
+			return observer;
+		}), (observer) => Effect.sync(() => observer.disconnect()));
+	}))
+});
+export { Intersection, IntersectionChanged };
+
+//# sourceMappingURL=intersection.js.map

package/dist/observers/intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.js","names":[],"sources":["../../src/observers/intersection.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const IntersectionChanged = Schema.TaggedStruct('IntersectionChanged', {\n  isIntersecting: Schema.Boolean,\n  ratio: Schema.Number,\n})\nexport type IntersectionChanged = typeof IntersectionChanged.Type\n\ntype ObserverCtor = new (callback: IntersectionObserverCallback) => IntersectionObserver\n\n/**\n * Element visibility as a Mount: IntersectionObserver reports viewport\n * crossings as Messages for the element carrying this Mount. No observer\n * (SSR, old browser) emits nothing instead of throwing.\n */\nexport const Intersection = Mount.defineStream('Intersection', {\n  messages: [IntersectionChanged],\n  execute: ({ element }) =>\n    Stream.callback<typeof IntersectionChanged.Type>(queue =>\n      Effect.gen(function* () {\n        const Observed = (globalThis as { IntersectionObserver?: ObserverCtor })\n          .IntersectionObserver\n        if (Observed === undefined) return\n        yield* Effect.acquireRelease(\n          Effect.sync(() => {\n            const observer = new Observed(entries => {\n              const first = entries[0]\n              if (first !== undefined) {\n                Queue.offerUnsafe(\n                  queue,\n                  IntersectionChanged.make({\n                    isIntersecting: first.isIntersecting,\n                    ratio: first.intersectionRatio,\n                  }),\n                )\n              }\n            })\n            observer.observe(element)\n            return observer\n          }),\n          observer => Effect.sync(() => observer.disconnect()),\n        )\n      }),\n    ),\n})\n"],"mappings":";;;AAGA,MAAa,sBAAsB,OAAO,aAAa,uBAAuB;CAC5E,gBAAgB,OAAO;CACvB,OAAO,OAAO;AAChB,CAAC;;;;;;AAUD,MAAa,eAAe,MAAM,aAAa,gBAAgB;CAC7D,UAAU,CAAC,mBAAmB;CAC9B,UAAU,EAAE,cACV,OAAO,UAA0C,UAC/C,OAAO,IAAI,aAAa;EACtB,MAAM,WAAY,WACf;EACH,IAAI,aAAa,KAAA,GAAW;EAC5B,OAAO,OAAO,eACZ,OAAO,WAAW;GAChB,MAAM,WAAW,IAAI,UAAS,YAAW;IACvC,MAAM,QAAQ,QAAQ;IACtB,IAAI,UAAU,KAAA,GACZ,MAAM,YACJ,OACA,oBAAoB,KAAK;KACvB,gBAAgB,MAAM;KACtB,OAAO,MAAM;IACf,CAAC,CACH;GAEJ,CAAC;GACD,SAAS,QAAQ,OAAO;GACxB,OAAO;EACT,CAAC,IACD,aAAY,OAAO,WAAW,SAAS,WAAW,CAAC,CACrD;CACF,CAAC,CACH;AACJ,CAAC"}

package/dist/observers/mutation.d.ts

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const Mutated: Schema.TaggedStruct<"Mutated", {
+  readonly type: Schema.Literals<readonly ["childList", "attributes", "characterData"]>;
+  readonly added: Schema.$Array<Schema.String>;
+  readonly removed: Schema.$Array<Schema.String>;
+  readonly attribute: Schema.NullOr<Schema.String>;
+}>;
+export type Mutated = typeof Mutated.Type;
+/**
+ * DOM mutations as a Mount: MutationObserver reports child, attribute, and
+ * text changes as Messages for the element carrying this Mount. Nodes cross
+ * as their names (serializable); the live nodes stay in the DOM, never in
+ * the Model. No observer (SSR, old browser) emits nothing instead of
+ * throwing. Observes the whole subtree — narrow by placing on a smaller
+ * element, not by options.
+ */
+export declare const Mutation: Mount.MountDefinitionNoArgs<"Mutation", {
+  readonly _tag: "Mutated";
+  readonly type: "attributes" | "characterData" | "childList";
+  readonly added: readonly string[];
+  readonly removed: readonly string[];
+  readonly attribute: string | null;
+}>;
+//# sourceMappingURL=mutation.d.ts.map

package/dist/observers/mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.d.ts","names":[],"sources":["../../src/observers/mutation.ts"],"mappings":";;qBAGa,SAAO,OAAA;;;;;;YAMR,iBAAiB,QAAQ;;;;;;;;;qBAexB,UAAQ,MAAA"}