foldkit-primitives 0.15.4 → 0.16.0

package/dist/media/platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","names":[],"sources":["../../src/media/platform.ts"],"sourcesContent":["/**\n * Platform detection as pure functions. `platformFromUA` reads a user-agent\n * string (passed in, so tests pin it without stubbing globals); order\n * matters — Android contains \"Linux\", iPhones mention \"Mac\" — so mobile\n * checks come first. `isBrowser`/`isServer` split SSR from client for init\n * defaults.\n */\nexport const Platform = ['mac', 'windows', 'linux', 'android', 'ios', 'unknown'] as const\nexport type Platform = (typeof Platform)[number]\n\n/**\n * Client Hints (`navigator.userAgentData`) plus touch points\n * (`navigator.maxTouchPoints`), passed in so detection stays pure and\n * pinned. Only `platform` and `touchPoints` can change the answer — the\n * `mobile` flag never disambiguates on its own, so it is not accepted.\n */\nexport interface PlatformHints {\n  readonly platform?: string | undefined\n  readonly touchPoints?: number | undefined\n}\n\nconst hintedPlatform = (platform: string): Platform | null => {\n  switch (platform.toLowerCase()) {\n    case 'macos':\n      return 'mac'\n    case 'windows':\n      return 'windows'\n    case 'linux':\n      return 'linux'\n    case 'android':\n      return 'android'\n    case 'ios':\n      return 'ios'\n    default:\n      return null\n  }\n}\n\n/**\n * The platform a user-agent string names, preferring Client Hints when given\n * (`navigator.userAgentData.platform`), with touch points telling a desktop-mode\n * iPad from a Mac. `unknown` when nothing matches.\n */\nexport const platformFromUA = (userAgent: string, hints: PlatformHints = {}): Platform => {\n  const hinted = hints.platform === undefined ? null : hintedPlatform(hints.platform)\n  const ua = userAgent.toLowerCase()\n  let sniffed: Platform = 'unknown'\n  if (ua.includes('android')) sniffed = 'android'\n  else if (ua.includes('iphone') || ua.includes('ipad') || ua.includes('ipod')) sniffed = 'ios'\n  else if (ua.includes('windows') || ua.includes('win32') || ua.includes('win64')) {\n    sniffed = 'windows'\n  } else if (ua.includes('macintosh') || ua.includes('mac os')) sniffed = 'mac'\n  else if (ua.includes('linux')) sniffed = 'linux'\n  const candidate = hinted ?? sniffed\n  // Desktop-mode iPads report \"macOS\" with a tablet touchscreen: only a\n  // multi-touch Mac UA is really an iPad. Touchscreen Windows and Linux\n  // machines keep their platform.\n  return candidate === 'mac' && (hints.touchPoints ?? 0) > 1 ? 'ios' : candidate\n}\n\n/** Whether a window exists: the client side of an SSR split. */\nexport const isBrowser = (): boolean => typeof window !== 'undefined'\n\n/** Whether no window exists: the server side of an SSR split. */\nexport const isServer = (): boolean => !isBrowser()\n"],"mappings":";;;;;;;;AAOA,MAAa,WAAW;CAAC;CAAO;CAAW;CAAS;CAAW;CAAO;AAAS;AAc/E,MAAM,kBAAkB,aAAsC;CAC5D,QAAQ,SAAS,YAAY,GAA7B;EACE,KAAK,SACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,SACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;AAOA,MAAa,kBAAkB,WAAmB,QAAuB,CAAC,MAAgB;CACxF,MAAM,SAAS,MAAM,aAAa,KAAA,IAAY,OAAO,eAAe,MAAM,QAAQ;CAClF,MAAM,KAAK,UAAU,YAAY;CACjC,IAAI,UAAoB;CACxB,IAAI,GAAG,SAAS,SAAS,GAAG,UAAU;MACjC,IAAI,GAAG,SAAS,QAAQ,KAAK,GAAG,SAAS,MAAM,KAAK,GAAG,SAAS,MAAM,GAAG,UAAU;MACnF,IAAI,GAAG,SAAS,SAAS,KAAK,GAAG,SAAS,OAAO,KAAK,GAAG,SAAS,OAAO,GAC5E,UAAU;MACL,IAAI,GAAG,SAAS,WAAW,KAAK,GAAG,SAAS,QAAQ,GAAG,UAAU;MACnE,IAAI,GAAG,SAAS,OAAO,GAAG,UAAU;CACzC,MAAM,YAAY,UAAU;CAI5B,OAAO,cAAc,UAAU,MAAM,eAAe,KAAK,IAAI,QAAQ;AACvE;;AAGA,MAAa,kBAA2B,OAAO,WAAW;;AAG1D,MAAa,iBAA0B,CAAC,UAAU"}

package/dist/motion/index.d.ts

@@ -0,0 +1,5 @@
+import * as Motion from "./motion.js";
+export * from "./presence.js";
+export * from "./spring.js";
+export * from "./tween.js";
+export { Motion };

package/dist/motion/index.js

@@ -0,0 +1,5 @@
+import * as Motion from "./motion.js";
+export * from "./presence.js";
+export * from "./spring.js";
+export * from "./tween.js";
+export { Motion };

package/dist/motion/motion.d.ts

@@ -0,0 +1,16 @@
+import { Context, Effect, Layer } from "effect";
+export interface MotionShape {
+  readonly reduced: Effect.Effect<boolean>;
+}
+declare const Motion_base: Context.ServiceClass<Motion, "foldkit-primitives/Motion", MotionShape>;
+export declare class Motion extends Motion_base {}
+/** Reduced or full motion, fixed: for a test or a setting the application owns. */
+export declare const layer: (reduced: boolean) => Layer.Layer<Motion>;
+export declare const reduced: Layer.Layer<Motion>;
+export declare const full: Layer.Layer<Motion>;
+/** The user's `prefers-reduced-motion`, read each time a transition starts. */
+export declare const live: Layer.Layer<Motion>;
+/** Whether to reduce motion now: the service's answer, or `false` without one. */
+export declare const reducedMotion: Effect.Effect<boolean>;
+export {};
+//# sourceMappingURL=motion.d.ts.map

package/dist/motion/motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","names":[],"sources":["../../src/motion/motion.ts"],"mappings":";iBAUiB;WACN,SAAS,OAAO;;;qBAGd,eAAe;;qBAGf,QAAK,qBAAuB,MAAM,MAAM;qBAGxC,SAAS,MAAM,MAAM;qBACrB,MAAM,MAAM,MAAM;;qBAGlB,MAAM,MAAM,MAAM;;qBAUlB,eAAe,OAAO"}

package/dist/motion/motion.js

@@ -0,0 +1,25 @@
+import { Context, Effect, Layer, Option } from "effect";
+// src/motion/motion.ts
+/**
+* Whether motion should be reduced, as a service read when a transition
+* starts, not sniffed once. Absent, motion is full, so a placement that
+* provides nothing behaves as before; a page provides `live` (the user's
+* `prefers-reduced-motion`) and a test provides `reduced` or `full`. Under
+* reduced motion a presence exits at once and a tween or spring jumps to its
+* end, in the same Messages, so the Model sees the same transitions.
+*/
+var Motion = class extends Context.Service()("foldkit-primitives/Motion") {};
+/** Reduced or full motion, fixed: for a test or a setting the application owns. */
+const layer = (reduced) => Layer.succeed(Motion, { reduced: Effect.succeed(reduced) });
+const reduced = layer(true);
+const full = layer(false);
+/** The user's `prefers-reduced-motion`, read each time a transition starts. */
+const live = Layer.succeed(Motion, { reduced: Effect.sync(() => typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches) });
+/** Whether to reduce motion now: the service's answer, or `false` without one. */
+const reducedMotion = Effect.flatMap(Effect.serviceOption(Motion), Option.match({
+	onNone: () => Effect.succeed(false),
+	onSome: (motion) => motion.reduced
+}));
+export { Motion, full, layer, live, reduced, reducedMotion };
+
+//# sourceMappingURL=motion.js.map

package/dist/motion/motion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.js","names":[],"sources":["../../src/motion/motion.ts"],"sourcesContent":["/**\n * Whether motion should be reduced, as a service read when a transition\n * starts, not sniffed once. Absent, motion is full, so a placement that\n * provides nothing behaves as before; a page provides `live` (the user's\n * `prefers-reduced-motion`) and a test provides `reduced` or `full`. Under\n * reduced motion a presence exits at once and a tween or spring jumps to its\n * end, in the same Messages, so the Model sees the same transitions.\n */\nimport { Context, Effect, Layer, Option } from 'effect'\n\nexport interface MotionShape {\n  readonly reduced: Effect.Effect<boolean>\n}\n\nexport class Motion extends Context.Service<Motion, MotionShape>()('foldkit-primitives/Motion') {}\n\n/** Reduced or full motion, fixed: for a test or a setting the application owns. */\nexport const layer = (reduced: boolean): Layer.Layer<Motion> =>\n  Layer.succeed(Motion, { reduced: Effect.succeed(reduced) })\n\nexport const reduced: Layer.Layer<Motion> = layer(true)\nexport const full: Layer.Layer<Motion> = layer(false)\n\n/** The user's `prefers-reduced-motion`, read each time a transition starts. */\nexport const live: Layer.Layer<Motion> = Layer.succeed(Motion, {\n  reduced: Effect.sync(\n    () =>\n      typeof window !== 'undefined' &&\n      typeof window.matchMedia === 'function' &&\n      window.matchMedia('(prefers-reduced-motion: reduce)').matches,\n  ),\n})\n\n/** Whether to reduce motion now: the service's answer, or `false` without one. */\nexport const reducedMotion: Effect.Effect<boolean> = Effect.flatMap(\n  Effect.serviceOption(Motion),\n  Option.match({ onNone: () => Effect.succeed(false), onSome: motion => motion.reduced }),\n)\n"],"mappings":";;;;;;;;;;AAcA,IAAa,SAAb,cAA4B,QAAQ,QAA6B,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC;;AAGjG,MAAa,SAAS,YACpB,MAAM,QAAQ,QAAQ,EAAE,SAAS,OAAO,QAAQ,OAAO,EAAE,CAAC;AAE5D,MAAa,UAA+B,MAAM,IAAI;AACtD,MAAa,OAA4B,MAAM,KAAK;;AAGpD,MAAa,OAA4B,MAAM,QAAQ,QAAQ,EAC7D,SAAS,OAAO,WAEZ,OAAO,WAAW,eAClB,OAAO,OAAO,eAAe,cAC7B,OAAO,WAAW,kCAAkC,CAAC,CAAC,OAC1D,EACF,CAAC;;AAGD,MAAa,gBAAwC,OAAO,QAC1D,OAAO,cAAc,MAAM,GAC3B,OAAO,MAAM;CAAE,cAAc,OAAO,QAAQ,KAAK;CAAG,SAAQ,WAAU,OAAO;AAAQ,CAAC,CACxF"}

package/dist/motion/presence.d.ts

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const PresenceModel: Schema.Struct<{
+  readonly phase: Schema.Literals<readonly ["shown", "hiding", "hidden"]>;
+  readonly generation: Schema.Number;
+}>;
+export type PresenceModel = typeof PresenceModel.Type;
+export declare const PresenceMessage: import("foldkit/message").MessageUnion<{
+  readonly Show: {};
+  readonly Hide: {};
+  readonly Hidden: {
+    generation: Schema.Number;
+  };
+}>;
+export type PresenceMessage = typeof PresenceMessage.Type;
+/** Whether the content renders: shown or mid-exit. */
+export declare const isVisible: (model: PresenceModel) => boolean;
+/**
+ * Presence as a bundle: mount-transition state for exit animations. `Hide`
+ * starts a timed `hiding` phase; the `Hidden` fact it yields carries the
+ * generation it was scheduled under, so a `Show` in between wins and the
+ * late fact is ignored. The clock is Effect's, so tests drive it.
+ */
+export declare const Presence: Bundle.Bundle<"Presence", {
+  readonly durationMs: number;
+}, {
+  readonly phase: "hidden" | "hiding" | "shown";
+  readonly generation: number;
+}, {
+  readonly _tag: "Hidden";
+  readonly generation: number;
+} | {
+  readonly _tag: "Hide";
+} | {
+  readonly _tag: "Show";
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=presence.d.ts.map

package/dist/motion/presence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.d.ts","names":[],"sources":["../../src/motion/presence.ts"],"mappings":";;qBAMa,eAAa,OAAA;;;;YAId,uBAAuB,cAAc;qBAEpC,2CAAe;;;;IAGhB,YAAU,OAAA;;;YAEV,yBAAyB,gBAAgB;;qBAGxC,YAAS,OAAW;;;;;;;qBAQpB,UAAQ,OAAA"}

package/dist/motion/presence.js

@@ -0,0 +1,65 @@
+import { Effect, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import { reducedMotion } from "./motion.js";
+// src/motion/presence.ts
+const PresenceModel = Schema.Struct({
+	phase: Schema.Literals([
+		"shown",
+		"hiding",
+		"hidden"
+	]),
+	generation: Schema.Number
+});
+const PresenceMessage = defineMessageUnion({
+	Show: {},
+	Hide: {},
+	Hidden: { generation: Schema.Number }
+});
+/** Whether the content renders: shown or mid-exit. */
+const isVisible = (model) => model.phase !== "hidden";
+/**
+* Presence as a bundle: mount-transition state for exit animations. `Hide`
+* starts a timed `hiding` phase; the `Hidden` fact it yields carries the
+* generation it was scheduled under, so a `Show` in between wins and the
+* late fact is ignored. The clock is Effect's, so tests drive it.
+*/
+const Presence = Bundle.make("Presence", {
+	Model: PresenceModel,
+	Message: PresenceMessage,
+	args: Schema.Struct({ durationMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
+	init: () => ({ model: {
+		phase: "hidden",
+		generation: 0
+	} }),
+	update: (model, message, args) => PresenceMessage.match(message, {
+		Show: () => model.phase === "shown" ? { model } : { model: {
+			...model,
+			phase: "shown",
+			generation: model.generation + 1
+		} },
+		Hide: () => {
+			if (model.phase === "hidden") return { model };
+			const generation = model.generation + 1;
+			return {
+				model: {
+					...model,
+					phase: "hiding",
+					generation
+				},
+				commands: [{
+					name: "Presence.hide",
+					args: { generation },
+					effect: Effect.flatMap(reducedMotion, (reduced) => reduced ? Effect.succeed(PresenceMessage.Hidden({ generation })) : Effect.as(Effect.sleep(args.durationMs), PresenceMessage.Hidden({ generation })))
+				}]
+			};
+		},
+		Hidden: ({ generation }) => generation === model.generation ? { model: {
+			...model,
+			phase: "hidden"
+		} } : { model }
+	})
+});
+export { Presence, PresenceMessage, PresenceModel, isVisible };
+
+//# sourceMappingURL=presence.js.map

package/dist/motion/presence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.js","names":[],"sources":["../../src/motion/presence.ts"],"sourcesContent":["import { Effect, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\nimport { reducedMotion } from './motion.js'\n\nexport const PresenceModel = Schema.Struct({\n  phase: Schema.Literals(['shown', 'hiding', 'hidden']),\n  generation: Schema.Number,\n})\nexport type PresenceModel = typeof PresenceModel.Type\n\nexport const PresenceMessage = defineMessageUnion({\n  Show: {},\n  Hide: {},\n  Hidden: { generation: Schema.Number },\n})\nexport type PresenceMessage = typeof PresenceMessage.Type\n\n/** Whether the content renders: shown or mid-exit. */\nexport const isVisible = (model: PresenceModel): boolean => model.phase !== 'hidden'\n\n/**\n * Presence as a bundle: mount-transition state for exit animations. `Hide`\n * starts a timed `hiding` phase; the `Hidden` fact it yields carries the\n * generation it was scheduled under, so a `Show` in between wins and the\n * late fact is ignored. The clock is Effect's, so tests drive it.\n */\nexport const Presence = Bundle.make('Presence', {\n  Model: PresenceModel,\n  Message: PresenceMessage,\n  args: Schema.Struct({\n    durationMs: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n  }),\n  init: () => ({ model: { phase: 'hidden', generation: 0 } }),\n  update: (model, message, args) =>\n    PresenceMessage.match<Update.ReturnWithOutMessage<PresenceModel, PresenceMessage, never>>(\n      message,\n      {\n        // Every new transition invalidates pending timeouts. While shown none is\n        // pending, and hiding what is hidden would show it for `durationMs`.\n        Show: () =>\n          model.phase === 'shown'\n            ? { model }\n            : { model: { ...model, phase: 'shown' as const, generation: model.generation + 1 } },\n        Hide: () => {\n          if (model.phase === 'hidden') return { model }\n          const generation = model.generation + 1\n          return {\n            model: { ...model, phase: 'hiding' as const, generation },\n            commands: [\n              {\n                name: 'Presence.hide',\n                args: { generation },\n                effect: Effect.flatMap(reducedMotion, reduced =>\n                  reduced\n                    ? Effect.succeed(PresenceMessage.Hidden({ generation }))\n                    : Effect.as(\n                        Effect.sleep(args.durationMs),\n                        PresenceMessage.Hidden({ generation }),\n                      ),\n                ),\n              },\n            ],\n          }\n        },\n        Hidden: ({ generation }) =>\n          generation === model.generation\n            ? { model: { ...model, phase: 'hidden' as const } }\n            : { model },\n      },\n    ),\n})\n"],"mappings":";;;;;AAMA,MAAa,gBAAgB,OAAO,OAAO;CACzC,OAAO,OAAO,SAAS;EAAC;EAAS;EAAU;CAAQ,CAAC;CACpD,YAAY,OAAO;AACrB,CAAC;AAGD,MAAa,kBAAkB,mBAAmB;CAChD,MAAM,CAAC;CACP,MAAM,CAAC;CACP,QAAQ,EAAE,YAAY,OAAO,OAAO;AACtC,CAAC;;AAID,MAAa,aAAa,UAAkC,MAAM,UAAU;;;;;;;AAQ5E,MAAa,WAAW,OAAO,KAAK,YAAY;CAC9C,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO,EAClB,YAAY,OAAO,OAAO,KACxB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC,EACF,CAAC;CACD,aAAa,EAAE,OAAO;EAAE,OAAO;EAAU,YAAY;CAAE,EAAE;CACzD,SAAS,OAAO,SAAS,SACvB,gBAAgB,MACd,SACA;EAGE,YACE,MAAM,UAAU,UACZ,EAAE,MAAM,IACR,EAAE,OAAO;GAAE,GAAG;GAAO,OAAO;GAAkB,YAAY,MAAM,aAAa;EAAE,EAAE;EACvF,YAAY;GACV,IAAI,MAAM,UAAU,UAAU,OAAO,EAAE,MAAM;GAC7C,MAAM,aAAa,MAAM,aAAa;GACtC,OAAO;IACL,OAAO;KAAE,GAAG;KAAO,OAAO;KAAmB;IAAW;IACxD,UAAU,CACR;KACE,MAAM;KACN,MAAM,EAAE,WAAW;KACnB,QAAQ,OAAO,QAAQ,gBAAe,YACpC,UACI,OAAO,QAAQ,gBAAgB,OAAO,EAAE,WAAW,CAAC,CAAC,IACrD,OAAO,GACL,OAAO,MAAM,KAAK,UAAU,GAC5B,gBAAgB,OAAO,EAAE,WAAW,CAAC,CACvC,CACN;IACF,CACF;GACF;EACF;EACA,SAAS,EAAE,iBACT,eAAe,MAAM,aACjB,EAAE,OAAO;GAAE,GAAG;GAAO,OAAO;EAAkB,EAAE,IAChD,EAAE,MAAM;CAChB,CACF;AACJ,CAAC"}

package/dist/motion/spring.d.ts

@@ -0,0 +1,50 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const SpringModel: Schema.Struct<{
+  readonly value: Schema.Number;
+  readonly velocity: Schema.Number;
+  readonly running: Schema.Boolean;
+}>;
+export type SpringModel = typeof SpringModel.Type;
+export declare const SpringMessage: import("foldkit/message").MessageUnion<{
+  readonly Started: {};
+  readonly Stopped: {};
+  readonly Ticked: {
+    value: Schema.Number;
+    velocity: Schema.Number;
+  };
+  /** Carries the exact end value: the integrator stops near it, not on it. */
+  readonly Finished: {
+    value: Schema.Number;
+  };
+}>;
+export type SpringMessage = typeof SpringMessage.Type;
+/**
+ * A spring as a bundle: a number pulled toward a target with stiffness and
+ * damping, in the Model. Semi-implicit Euler at a fixed 16ms step, so the
+ * trajectory is deterministic under TestClock; the stream ends with
+ * Finished, and the value rests exactly at `to`. Underdamped springs
+ * overshoot — that is the point — but the rest value is still exact.
+ */
+export declare const Spring: Bundle.Bundle<"Spring", {
+  readonly from: number;
+  readonly to: number;
+  readonly stiffness: number;
+  readonly damping: number;
+}, {
+  readonly value: number;
+  readonly velocity: number;
+  readonly running: boolean;
+}, {
+  readonly _tag: "Finished";
+  readonly value: number;
+} | {
+  readonly _tag: "Started";
+} | {
+  readonly _tag: "Stopped";
+} | {
+  readonly _tag: "Ticked";
+  readonly value: number;
+  readonly velocity: number;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=spring.d.ts.map

package/dist/motion/spring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring.d.ts","names":[],"sources":["../../src/motion/spring.ts"],"mappings":";;qBAMa,aAAW,OAAA;;;;;YAKZ,qBAAqB,YAAY;qBAEhC,yCAAa;;;;IAGd,OAAK,OAAA;IAAiB,UAAQ,OAAA;;;;IAE5B,OAAK,OAAA;;;YAEP,uBAAuB,cAAc;;;;;;;;qBAoBpC,QAAM,OAAA"}

package/dist/motion/spring.js

@@ -0,0 +1,92 @@
+import { Effect, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+import { reducedMotion } from "./motion.js";
+// src/motion/spring.ts
+const SpringModel = Schema.Struct({
+	value: Schema.Number,
+	velocity: Schema.Number,
+	running: Schema.Boolean
+});
+const SpringMessage = defineMessageUnion({
+	Started: {},
+	Stopped: {},
+	Ticked: {
+		value: Schema.Number,
+		velocity: Schema.Number
+	},
+	/** Carries the exact end value: the integrator stops near it, not on it. */
+	Finished: { value: Schema.Number }
+});
+const step = 16;
+const epsilon = .001;
+const settled = (point, to) => Math.abs(to - point.x) < epsilon && Math.abs(point.v) < epsilon;
+/**
+* A spring as a bundle: a number pulled toward a target with stiffness and
+* damping, in the Model. Semi-implicit Euler at a fixed 16ms step, so the
+* trajectory is deterministic under TestClock; the stream ends with
+* Finished, and the value rests exactly at `to`. Underdamped springs
+* overshoot — that is the point — but the rest value is still exact.
+*/
+const Spring = Bundle.make("Spring", {
+	Model: SpringModel,
+	Message: SpringMessage,
+	args: Schema.Struct({
+		from: Schema.Number.pipe(Schema.check(Schema.isFinite())),
+		to: Schema.Number.pipe(Schema.check(Schema.isFinite())),
+		stiffness: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())),
+		damping: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite()))
+	}),
+	init: (args) => ({ model: {
+		value: args.from,
+		velocity: 0,
+		running: false
+	} }),
+	update: (model, message) => SpringMessage.match(message, {
+		Started: () => model.running ? { model } : { model: {
+			...model,
+			running: true
+		} },
+		Stopped: () => model.running ? { model: {
+			...model,
+			running: false
+		} } : { model },
+		Ticked: ({ value, velocity }) => ({ model: {
+			...model,
+			value,
+			velocity
+		} }),
+		Finished: ({ value }) => ({ model: {
+			...model,
+			value,
+			velocity: 0,
+			running: false
+		} })
+	}),
+	subscriptions: ({ from, to, stiffness, damping }) => Subscription.make()((entry) => ({ ticks: entry({ running: Schema.Boolean }, {
+		modelToDependencies: (model) => ({ running: model.running }),
+		dependenciesToStream: ({ running }) => {
+			if (!running) return Stream.empty;
+			const dt = step / 1e3;
+			const points = Stream.tick(step).pipe(Stream.scan(() => ({
+				x: from,
+				v: 0
+			}), (point) => {
+				const force = -stiffness * (point.x - to) - damping * point.v;
+				const v = point.v + force * dt;
+				return {
+					x: point.x + v * dt,
+					v
+				};
+			}), Stream.drop(1));
+			return Stream.unwrap(Effect.map(reducedMotion, (reduced) => reduced ? Stream.make(SpringMessage.Finished({ value: to })) : Stream.concat(points.pipe(Stream.takeUntil((point) => settled(point, to)), Stream.map((point) => SpringMessage.Ticked({
+				value: point.x,
+				velocity: point.v
+			}))), Stream.make(SpringMessage.Finished({ value: to })))));
+		}
+	}) }))
+});
+export { Spring, SpringMessage, SpringModel };
+
+//# sourceMappingURL=spring.js.map

package/dist/motion/spring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring.js","names":[],"sources":["../../src/motion/spring.ts"],"sourcesContent":["import { Effect, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport { Bundle } from 'foldkit-bundle'\nimport { reducedMotion } from './motion.js'\n\nexport const SpringModel = Schema.Struct({\n  value: Schema.Number,\n  velocity: Schema.Number,\n  running: Schema.Boolean,\n})\nexport type SpringModel = typeof SpringModel.Type\n\nexport const SpringMessage = defineMessageUnion({\n  Started: {},\n  Stopped: {},\n  Ticked: { value: Schema.Number, velocity: Schema.Number },\n  /** Carries the exact end value: the integrator stops near it, not on it. */\n  Finished: { value: Schema.Number },\n})\nexport type SpringMessage = typeof SpringMessage.Type\n\nconst step = 16\nconst epsilon = 0.001\n\ninterface Point {\n  readonly x: number\n  readonly v: number\n}\n\nconst settled = (point: Point, to: number): boolean =>\n  Math.abs(to - point.x) < epsilon && Math.abs(point.v) < epsilon\n\n/**\n * A spring as a bundle: a number pulled toward a target with stiffness and\n * damping, in the Model. Semi-implicit Euler at a fixed 16ms step, so the\n * trajectory is deterministic under TestClock; the stream ends with\n * Finished, and the value rests exactly at `to`. Underdamped springs\n * overshoot — that is the point — but the rest value is still exact.\n */\nexport const Spring = Bundle.make('Spring', {\n  Model: SpringModel,\n  Message: SpringMessage,\n  args: Schema.Struct({\n    from: Schema.Number.pipe(Schema.check(Schema.isFinite())),\n    to: Schema.Number.pipe(Schema.check(Schema.isFinite())),\n    stiffness: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n    damping: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n  }),\n  init: args => ({ model: { value: args.from, velocity: 0, running: false } }),\n  update: (model, message) =>\n    SpringMessage.match(message, {\n      Started: () => (model.running ? { model } : { model: { ...model, running: true } }),\n      Stopped: () => (model.running ? { model: { ...model, running: false } } : { model }),\n      Ticked: ({ value, velocity }) => ({ model: { ...model, value, velocity } }),\n      Finished: ({ value }) => ({ model: { ...model, value, velocity: 0, running: false } }),\n    }),\n  subscriptions: ({\n    from,\n    to,\n    stiffness,\n    damping,\n  }): Subscription.Subscriptions<SpringModel, SpringMessage> =>\n    Subscription.make<SpringModel, SpringMessage>()(entry => ({\n      ticks: entry(\n        { running: Schema.Boolean },\n        {\n          modelToDependencies: model => ({ running: model.running }),\n          dependenciesToStream: ({ running }) => {\n            if (!running) return Stream.empty\n            // One integration step per tick, not per elapsed wall time: the\n            // trajectory is identical on the live clock and TestClock, and a\n            // stalled event loop slows the animation instead of catching up\n            // all at once.\n            const dt = step / 1000\n            const points = Stream.tick(step).pipe(\n              Stream.scan(\n                (): Point => ({ x: from, v: 0 }),\n                point => {\n                  const force = -stiffness * (point.x - to) - damping * point.v\n                  const v = point.v + force * dt\n                  return { x: point.x + v * dt, v }\n                },\n              ),\n              // scan emits the seed (no movement yet) before the first step.\n              Stream.drop(1),\n            )\n            return Stream.unwrap(\n              Effect.map(reducedMotion, reduced =>\n                reduced\n                  ? Stream.make(SpringMessage.Finished({ value: to }))\n                  : Stream.concat(\n                      points.pipe(\n                        Stream.takeUntil(point => settled(point, to)),\n                        Stream.map(point =>\n                          SpringMessage.Ticked({ value: point.x, velocity: point.v }),\n                        ),\n                      ),\n                      Stream.make(SpringMessage.Finished({ value: to })),\n                    ),\n              ),\n            )\n          },\n        },\n      ),\n    })),\n})\n"],"mappings":";;;;;;AAMA,MAAa,cAAc,OAAO,OAAO;CACvC,OAAO,OAAO;CACd,UAAU,OAAO;CACjB,SAAS,OAAO;AAClB,CAAC;AAGD,MAAa,gBAAgB,mBAAmB;CAC9C,SAAS,CAAC;CACV,SAAS,CAAC;CACV,QAAQ;EAAE,OAAO,OAAO;EAAQ,UAAU,OAAO;CAAO;;CAExD,UAAU,EAAE,OAAO,OAAO,OAAO;AACnC,CAAC;AAGD,MAAM,OAAO;AACb,MAAM,UAAU;AAOhB,MAAM,WAAW,OAAc,OAC7B,KAAK,IAAI,KAAK,MAAM,CAAC,IAAI,WAAW,KAAK,IAAI,MAAM,CAAC,IAAI;;;;;;;;AAS1D,MAAa,SAAS,OAAO,KAAK,UAAU;CAC1C,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO;EAClB,MAAM,OAAO,OAAO,KAAK,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC;EACxD,IAAI,OAAO,OAAO,KAAK,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC;EACtD,WAAW,OAAO,OAAO,KACvB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC;EACA,SAAS,OAAO,OAAO,KACrB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC;CACF,CAAC;CACD,OAAM,UAAS,EAAE,OAAO;EAAE,OAAO,KAAK;EAAM,UAAU;EAAG,SAAS;CAAM,EAAE;CAC1E,SAAS,OAAO,YACd,cAAc,MAAM,SAAS;EAC3B,eAAgB,MAAM,UAAU,EAAE,MAAM,IAAI,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAK,EAAE;EACjF,eAAgB,MAAM,UAAU,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAM,EAAE,IAAI,EAAE,MAAM;EAClF,SAAS,EAAE,OAAO,gBAAgB,EAAE,OAAO;GAAE,GAAG;GAAO;GAAO;EAAS,EAAE;EACzE,WAAW,EAAE,aAAa,EAAE,OAAO;GAAE,GAAG;GAAO;GAAO,UAAU;GAAG,SAAS;EAAM,EAAE;CACtF,CAAC;CACH,gBAAgB,EACd,MACA,IACA,WACA,cAEA,aAAa,KAAiC,CAAC,EAAC,WAAU,EACxD,OAAO,MACL,EAAE,SAAS,OAAO,QAAQ,GAC1B;EACE,sBAAqB,WAAU,EAAE,SAAS,MAAM,QAAQ;EACxD,uBAAuB,EAAE,cAAc;GACrC,IAAI,CAAC,SAAS,OAAO,OAAO;GAK5B,MAAM,KAAK,OAAO;GAClB,MAAM,SAAS,OAAO,KAAK,IAAI,CAAC,CAAC,KAC/B,OAAO,YACS;IAAE,GAAG;IAAM,GAAG;GAAE,KAC9B,UAAS;IACP,MAAM,QAAQ,CAAC,aAAa,MAAM,IAAI,MAAM,UAAU,MAAM;IAC5D,MAAM,IAAI,MAAM,IAAI,QAAQ;IAC5B,OAAO;KAAE,GAAG,MAAM,IAAI,IAAI;KAAI;IAAE;GAClC,CACF,GAEA,OAAO,KAAK,CAAC,CACf;GACA,OAAO,OAAO,OACZ,OAAO,IAAI,gBAAe,YACxB,UACI,OAAO,KAAK,cAAc,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,IACjD,OAAO,OACL,OAAO,KACL,OAAO,WAAU,UAAS,QAAQ,OAAO,EAAE,CAAC,GAC5C,OAAO,KAAI,UACT,cAAc,OAAO;IAAE,OAAO,MAAM;IAAG,UAAU,MAAM;GAAE,CAAC,CAC5D,CACF,GACA,OAAO,KAAK,cAAc,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,CACnD,CACN,CACF;EACF;CACF,CACF,EACF,EAAE;AACN,CAAC"}

package/dist/motion/tween.d.ts

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const TweenModel: Schema.Struct<{
+  readonly value: Schema.Number;
+  readonly running: Schema.Boolean;
+}>;
+export type TweenModel = typeof TweenModel.Type;
+export declare const TweenMessage: import("foldkit/message").MessageUnion<{
+  readonly Started: {};
+  readonly Stopped: {};
+  readonly Ticked: {
+    value: Schema.Number;
+  };
+  /** Carries the exact end value: the stream may stop on either side of it. */
+  readonly Finished: {
+    value: Schema.Number;
+  };
+}>;
+export type TweenMessage = typeof TweenMessage.Type;
+/**
+ * A tween as a bundle: a number animated from one value to another over a
+ * duration, in the Model. Progress comes from Effect's clock, so tests drive
+ * it with TestClock; the stream ends with Finished, and the value rests at
+ * `to`. Linear interpolation only: easing curves stay the application's job.
+ */
+export declare const Tween: Bundle.Bundle<"Tween", {
+  readonly from: number;
+  readonly to: number;
+  readonly ms: number;
+}, {
+  readonly value: number;
+  readonly running: boolean;
+}, {
+  readonly _tag: "Started";
+} | {
+  readonly _tag: "Stopped";
+} | {
+  readonly _tag: "Finished";
+  readonly value: number;
+} | {
+  readonly _tag: "Ticked";
+  readonly value: number;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=tween.d.ts.map

package/dist/motion/tween.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tween.d.ts","names":[],"sources":["../../src/motion/tween.ts"],"mappings":";;qBAMa,YAAU,OAAA;;;;YACX,oBAAoB,WAAW;qBAE9B,wCAAY;;;;IAGb,OAAK,OAAA;;;;IAEH,OAAK,OAAA;;;YAEP,sBAAsB,aAAa;;;;;;;qBAQlC,OAAK,OAAA"}

package/dist/motion/tween.js

@@ -0,0 +1,65 @@
+import { Clock, Effect, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+import { reducedMotion } from "./motion.js";
+// src/motion/tween.ts
+const TweenModel = Schema.Struct({
+	value: Schema.Number,
+	running: Schema.Boolean
+});
+const TweenMessage = defineMessageUnion({
+	Started: {},
+	Stopped: {},
+	Ticked: { value: Schema.Number },
+	/** Carries the exact end value: the stream may stop on either side of it. */
+	Finished: { value: Schema.Number }
+});
+/**
+* A tween as a bundle: a number animated from one value to another over a
+* duration, in the Model. Progress comes from Effect's clock, so tests drive
+* it with TestClock; the stream ends with Finished, and the value rests at
+* `to`. Linear interpolation only: easing curves stay the application's job.
+*/
+const Tween = Bundle.make("Tween", {
+	Model: TweenModel,
+	Message: TweenMessage,
+	args: Schema.Struct({
+		from: Schema.Number.pipe(Schema.check(Schema.isFinite())),
+		to: Schema.Number.pipe(Schema.check(Schema.isFinite())),
+		ms: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite()))
+	}),
+	init: (args) => ({ model: {
+		value: args.from,
+		running: false
+	} }),
+	update: (model, message) => TweenMessage.match(message, {
+		Started: () => model.running ? { model } : { model: {
+			...model,
+			running: true
+		} },
+		Stopped: () => model.running ? { model: {
+			...model,
+			running: false
+		} } : { model },
+		Ticked: ({ value }) => value === model.value ? { model } : { model: {
+			...model,
+			value
+		} },
+		Finished: ({ value }) => ({ model: {
+			...model,
+			value,
+			running: false
+		} })
+	}),
+	subscriptions: ({ from, to, ms }) => Subscription.make()((entry) => ({ ticks: entry({ running: Schema.Boolean }, {
+		modelToDependencies: (model) => ({ running: model.running }),
+		dependenciesToStream: ({ running }) => running ? Stream.unwrap(Effect.flatMap(reducedMotion, (reduced) => reduced ? Effect.succeed(Stream.make(TweenMessage.Finished({ value: to }))) : Clock.currentTimeMillis.pipe(Effect.map((startedAt) => {
+			const progress = Stream.tick(16).pipe(Stream.mapEffect(() => Clock.currentTimeMillis), Stream.map((now) => Math.min(1, (now - startedAt) / ms)));
+			return Stream.concat(progress.pipe(Stream.takeUntil((done) => done >= 1), Stream.map((done) => TweenMessage.Ticked({ value: from + (to - from) * done }))), Stream.make(TweenMessage.Finished({ value: to })));
+		})))) : Stream.empty
+	}) }))
+});
+export { Tween, TweenMessage, TweenModel };
+
+//# sourceMappingURL=tween.js.map

package/dist/motion/tween.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tween.js","names":[],"sources":["../../src/motion/tween.ts"],"sourcesContent":["import { Clock, Effect, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport { Bundle } from 'foldkit-bundle'\nimport { reducedMotion } from './motion.js'\n\nexport const TweenModel = Schema.Struct({ value: Schema.Number, running: Schema.Boolean })\nexport type TweenModel = typeof TweenModel.Type\n\nexport const TweenMessage = defineMessageUnion({\n  Started: {},\n  Stopped: {},\n  Ticked: { value: Schema.Number },\n  /** Carries the exact end value: the stream may stop on either side of it. */\n  Finished: { value: Schema.Number },\n})\nexport type TweenMessage = typeof TweenMessage.Type\n\n/**\n * A tween as a bundle: a number animated from one value to another over a\n * duration, in the Model. Progress comes from Effect's clock, so tests drive\n * it with TestClock; the stream ends with Finished, and the value rests at\n * `to`. Linear interpolation only: easing curves stay the application's job.\n */\nexport const Tween = Bundle.make('Tween', {\n  Model: TweenModel,\n  Message: TweenMessage,\n  args: Schema.Struct({\n    from: Schema.Number.pipe(Schema.check(Schema.isFinite())),\n    to: Schema.Number.pipe(Schema.check(Schema.isFinite())),\n    ms: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())),\n  }),\n  init: args => ({ model: { value: args.from, running: false } }),\n  update: (model, message) =>\n    TweenMessage.match(message, {\n      Started: () => (model.running ? { model } : { model: { ...model, running: true } }),\n      Stopped: () => (model.running ? { model: { ...model, running: false } } : { model }),\n      // The first tick lands at the start, on the value the Model already holds.\n      Ticked: ({ value }) => (value === model.value ? { model } : { model: { ...model, value } }),\n      Finished: ({ value }) => ({ model: { ...model, value, running: false } }),\n    }),\n  subscriptions: ({ from, to, ms }): Subscription.Subscriptions<TweenModel, TweenMessage> =>\n    Subscription.make<TweenModel, TweenMessage>()(entry => ({\n      ticks: entry(\n        { running: Schema.Boolean },\n        {\n          modelToDependencies: model => ({ running: model.running }),\n          dependenciesToStream: ({ running }) =>\n            running\n              ? Stream.unwrap(\n                  Effect.flatMap(reducedMotion, reduced =>\n                    reduced\n                      ? Effect.succeed(Stream.make(TweenMessage.Finished({ value: to })))\n                      : Clock.currentTimeMillis.pipe(\n                          Effect.map(startedAt => {\n                            const progress = Stream.tick(16).pipe(\n                              Stream.mapEffect(() => Clock.currentTimeMillis),\n                              Stream.map(now => Math.min(1, (now - startedAt) / ms)),\n                            )\n                            return Stream.concat(\n                              progress.pipe(\n                                Stream.takeUntil(done => done >= 1),\n                                Stream.map(done =>\n                                  TweenMessage.Ticked({ value: from + (to - from) * done }),\n                                ),\n                              ),\n                              Stream.make(TweenMessage.Finished({ value: to })),\n                            )\n                          }),\n                        ),\n                  ),\n                )\n              : Stream.empty,\n        },\n      ),\n    })),\n})\n"],"mappings":";;;;;;AAMA,MAAa,aAAa,OAAO,OAAO;CAAE,OAAO,OAAO;CAAQ,SAAS,OAAO;AAAQ,CAAC;AAGzF,MAAa,eAAe,mBAAmB;CAC7C,SAAS,CAAC;CACV,SAAS,CAAC;CACV,QAAQ,EAAE,OAAO,OAAO,OAAO;;CAE/B,UAAU,EAAE,OAAO,OAAO,OAAO;AACnC,CAAC;;;;;;;AASD,MAAa,QAAQ,OAAO,KAAK,SAAS;CACxC,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO;EAClB,MAAM,OAAO,OAAO,KAAK,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC;EACxD,IAAI,OAAO,OAAO,KAAK,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC;EACtD,IAAI,OAAO,OAAO,KAAK,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GAAG,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC;CAC/F,CAAC;CACD,OAAM,UAAS,EAAE,OAAO;EAAE,OAAO,KAAK;EAAM,SAAS;CAAM,EAAE;CAC7D,SAAS,OAAO,YACd,aAAa,MAAM,SAAS;EAC1B,eAAgB,MAAM,UAAU,EAAE,MAAM,IAAI,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAK,EAAE;EACjF,eAAgB,MAAM,UAAU,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAM,EAAE,IAAI,EAAE,MAAM;EAElF,SAAS,EAAE,YAAa,UAAU,MAAM,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO;GAAE,GAAG;GAAO;EAAM,EAAE;EACzF,WAAW,EAAE,aAAa,EAAE,OAAO;GAAE,GAAG;GAAO;GAAO,SAAS;EAAM,EAAE;CACzE,CAAC;CACH,gBAAgB,EAAE,MAAM,IAAI,SAC1B,aAAa,KAA+B,CAAC,EAAC,WAAU,EACtD,OAAO,MACL,EAAE,SAAS,OAAO,QAAQ,GAC1B;EACE,sBAAqB,WAAU,EAAE,SAAS,MAAM,QAAQ;EACxD,uBAAuB,EAAE,cACvB,UACI,OAAO,OACL,OAAO,QAAQ,gBAAe,YAC5B,UACI,OAAO,QAAQ,OAAO,KAAK,aAAa,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,IAChE,MAAM,kBAAkB,KACtB,OAAO,KAAI,cAAa;GACtB,MAAM,WAAW,OAAO,KAAK,EAAE,CAAC,CAAC,KAC/B,OAAO,gBAAgB,MAAM,iBAAiB,GAC9C,OAAO,KAAI,QAAO,KAAK,IAAI,IAAI,MAAM,aAAa,EAAE,CAAC,CACvD;GACA,OAAO,OAAO,OACZ,SAAS,KACP,OAAO,WAAU,SAAQ,QAAQ,CAAC,GAClC,OAAO,KAAI,SACT,aAAa,OAAO,EAAE,OAAO,QAAQ,KAAK,QAAQ,KAAK,CAAC,CAC1D,CACF,GACA,OAAO,KAAK,aAAa,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,CAClD;EACF,CAAC,CACH,CACN,CACF,IACA,OAAO;CACf,CACF,EACF,EAAE;AACN,CAAC"}

package/dist/net/broadcast.d.ts

@@ -0,0 +1,39 @@
+import { Schema, Stream } from "effect";
+import { Command } from "foldkit/command";
+export declare const BroadcastMessage: import("foldkit/message").MessageUnion<{
+  /** Notifies without storing: project the payload into your own field to keep it. */
+  readonly Received: {
+    data: Schema.Unknown;
+  };
+  readonly Posted: {};
+  readonly BroadcastFailed: {
+    message: Schema.String;
+  };
+}>;
+export type BroadcastMessage = typeof BroadcastMessage.Type;
+/** The slice of a BroadcastChannel this module needs; satisfied by the platform class. */
+export interface BroadcastChannelHandle {
+  postMessage(data: unknown): void;
+  close(): void;
+  onmessage: ((event: {
+    readonly data: unknown;
+  }) => void) | null;
+}
+type ChannelFactory = (name: string) => BroadcastChannelHandle;
+/**
+ * Every post to `name` from another channel, as Messages. Without a
+ * BroadcastChannel API the stream is empty instead of throwing; closing the
+ * stream closes the channel.
+ */
+export declare const broadcastMessages: (name: string,
+/** Read lazily so tests can substitute a double, like the SSE bundle. */
+create?: ChannelFactory | undefined) => Stream.Stream<BroadcastMessage>;
+/**
+ * Posts one message to `name`. Opens a channel, posts, and closes it: the
+ * send is one-shot, so it is a Command, not a resource. Without a
+ * BroadcastChannel API — or when the post throws — it yields
+ * `BroadcastFailed` instead of throwing.
+ */
+export declare const postBroadcast: (name: string, data: unknown, create?: ChannelFactory | undefined) => Command<BroadcastMessage, never, never>;
+export {};
+//# sourceMappingURL=broadcast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.d.ts","names":[],"sources":["../../src/net/broadcast.ts"],"mappings":";;qBAaa,4CAAgB;;;IAEf,MAAI,OAAA;;;;IAEG,SAAO,OAAA;;;YAEhB,0BAA0B,iBAAiB;;iBAGtC;EACf,YAAY;EACZ;EACA,aAAa;aAAkB;;;KAG5B,kBAAkB,iBAAiB;;;;;;qBAmB3B,oBAAiB;;AAGnB,SAAA,+BACR,OAAO,OAAO;;;;;;;qBAyBJ,gBAAa,cACZ,eACC,SACJ,+BACR,QAAQ"}

package/dist/net/broadcast.js

@@ -0,0 +1,73 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/net/broadcast.ts
+/**
+* Cross-tab messaging as an entry plus a Command — not a bundle, because the
+* channel owns no state: the parent maps `Received` into its own Message and
+* stores whatever it keeps. One assembly may open the same name twice (two
+* listeners); share the entry instead. By spec a post reaches every channel
+* of its name but the one it was posted on, and `postBroadcast` posts on a
+* channel of its own: a tab's `broadcastMessages` hears that tab's posts.
+* Name the sender in `data` to tell them apart.
+*/
+const BroadcastMessage = defineMessageUnion({
+	/** Notifies without storing: project the payload into your own field to keep it. */
+	Received: { data: Schema.Unknown },
+	Posted: {},
+	BroadcastFailed: { message: Schema.String }
+});
+const failMessage = (error) => error instanceof Error ? error.message : String(error);
+const createChannel = (factory, name) => {
+	if (factory !== void 0) return factory(name);
+	if (typeof BroadcastChannel === "undefined") return null;
+	return new BroadcastChannel(name);
+};
+/**
+* Every post to `name` from another channel, as Messages. Without a
+* BroadcastChannel API the stream is empty instead of throwing; closing the
+* stream closes the channel.
+*/
+const broadcastMessages = (name, create) => Stream.unwrap(Effect.gen(function* () {
+	const channel = createChannel(create, name);
+	if (channel === null) return Stream.empty;
+	const queue = yield* Queue.unbounded();
+	channel.onmessage = (event) => {
+		Effect.runFork(Queue.offer(queue, BroadcastMessage.Received({ data: event.data })));
+	};
+	yield* Effect.addFinalizer(() => Effect.sync(() => {
+		channel.onmessage = null;
+		channel.close();
+	}));
+	return Stream.fromQueue(queue);
+}));
+/**
+* Posts one message to `name`. Opens a channel, posts, and closes it: the
+* send is one-shot, so it is a Command, not a resource. Without a
+* BroadcastChannel API — or when the post throws — it yields
+* `BroadcastFailed` instead of throwing.
+*/
+const postBroadcast = (name, data, create) => ({
+	name: "Broadcast.post",
+	args: {
+		name,
+		data
+	},
+	effect: Effect.matchEffect(Effect.try({
+		try: () => {
+			const channel = createChannel(create, name);
+			if (channel === null) throw new Error("broadcast is unavailable");
+			try {
+				channel.postMessage(data);
+			} finally {
+				channel.close();
+			}
+		},
+		catch: failMessage
+	}), {
+		onFailure: (message) => Effect.succeed(BroadcastMessage.BroadcastFailed({ message })),
+		onSuccess: () => Effect.succeed(BroadcastMessage.Posted())
+	})
+});
+export { BroadcastMessage, broadcastMessages, postBroadcast };
+
+//# sourceMappingURL=broadcast.js.map

package/dist/net/broadcast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.js","names":[],"sources":["../../src/net/broadcast.ts"],"sourcesContent":["/**\n * Cross-tab messaging as an entry plus a Command — not a bundle, because the\n * channel owns no state: the parent maps `Received` into its own Message and\n * stores whatever it keeps. One assembly may open the same name twice (two\n * listeners); share the entry instead. By spec a post reaches every channel\n * of its name but the one it was posted on, and `postBroadcast` posts on a\n * channel of its own: a tab's `broadcastMessages` hears that tab's posts.\n * Name the sender in `data` to tell them apart.\n */\nimport { Effect, Queue, Schema, Stream } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const BroadcastMessage = defineMessageUnion({\n  /** Notifies without storing: project the payload into your own field to keep it. */\n  Received: { data: Schema.Unknown },\n  Posted: {},\n  BroadcastFailed: { message: Schema.String },\n})\nexport type BroadcastMessage = typeof BroadcastMessage.Type\n\n/** The slice of a BroadcastChannel this module needs; satisfied by the platform class. */\nexport interface BroadcastChannelHandle {\n  postMessage(data: unknown): void\n  close(): void\n  onmessage: ((event: { readonly data: unknown }) => void) | null\n}\n\ntype ChannelFactory = (name: string) => BroadcastChannelHandle\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst createChannel = (\n  factory: ChannelFactory | undefined,\n  name: string,\n): BroadcastChannelHandle | null => {\n  if (factory !== undefined) return factory(name)\n  if (typeof BroadcastChannel === 'undefined') return null\n  return new BroadcastChannel(name) as unknown as BroadcastChannelHandle\n}\n\n/**\n * Every post to `name` from another channel, as Messages. Without a\n * BroadcastChannel API the stream is empty instead of throwing; closing the\n * stream closes the channel.\n */\nexport const broadcastMessages = (\n  name: string,\n  /** Read lazily so tests can substitute a double, like the SSE bundle. */\n  create?: ChannelFactory | undefined,\n): Stream.Stream<BroadcastMessage> =>\n  Stream.unwrap(\n    Effect.gen(function* () {\n      const channel = createChannel(create, name)\n      if (channel === null) return Stream.empty\n      const queue = yield* Queue.unbounded<BroadcastMessage>()\n      channel.onmessage = event => {\n        Effect.runFork(Queue.offer(queue, BroadcastMessage.Received({ data: event.data })))\n      }\n      yield* Effect.addFinalizer(() =>\n        Effect.sync(() => {\n          channel.onmessage = null\n          channel.close()\n        }),\n      )\n      return Stream.fromQueue(queue)\n    }),\n  )\n\n/**\n * Posts one message to `name`. Opens a channel, posts, and closes it: the\n * send is one-shot, so it is a Command, not a resource. Without a\n * BroadcastChannel API — or when the post throws — it yields\n * `BroadcastFailed` instead of throwing.\n */\nexport const postBroadcast = (\n  name: string,\n  data: unknown,\n  create?: ChannelFactory | undefined,\n): Command<BroadcastMessage, never, never> => ({\n  name: 'Broadcast.post',\n  args: { name, data },\n  // One path for every failure: no factory and no platform API, or a post\n  // that throws (a closed channel) all become BroadcastFailed.\n  effect: Effect.matchEffect(\n    Effect.try({\n      try: () => {\n        const channel = createChannel(create, name)\n        if (channel === null) throw new Error('broadcast is unavailable')\n        try {\n          channel.postMessage(data)\n        } finally {\n          channel.close()\n        }\n      },\n      catch: failMessage,\n    }),\n    {\n      onFailure: message => Effect.succeed(BroadcastMessage.BroadcastFailed({ message })),\n      onSuccess: () => Effect.succeed(BroadcastMessage.Posted()),\n    },\n  ),\n})\n"],"mappings":";;;;;;;;;;;;AAaA,MAAa,mBAAmB,mBAAmB;;CAEjD,UAAU,EAAE,MAAM,OAAO,QAAQ;CACjC,QAAQ,CAAC;CACT,iBAAiB,EAAE,SAAS,OAAO,OAAO;AAC5C,CAAC;AAYD,MAAM,eAAe,UACnB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAEvD,MAAM,iBACJ,SACA,SACkC;CAClC,IAAI,YAAY,KAAA,GAAW,OAAO,QAAQ,IAAI;CAC9C,IAAI,OAAO,qBAAqB,aAAa,OAAO;CACpD,OAAO,IAAI,iBAAiB,IAAI;AAClC;;;;;;AAOA,MAAa,qBACX,MAEA,WAEA,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,cAAc,QAAQ,IAAI;CAC1C,IAAI,YAAY,MAAM,OAAO,OAAO;CACpC,MAAM,QAAQ,OAAO,MAAM,UAA4B;CACvD,QAAQ,aAAY,UAAS;EAC3B,OAAO,QAAQ,MAAM,MAAM,OAAO,iBAAiB,SAAS,EAAE,MAAM,MAAM,KAAK,CAAC,CAAC,CAAC;CACpF;CACA,OAAO,OAAO,mBACZ,OAAO,WAAW;EAChB,QAAQ,YAAY;EACpB,QAAQ,MAAM;CAChB,CAAC,CACH;CACA,OAAO,OAAO,UAAU,KAAK;AAC/B,CAAC,CACH;;;;;;;AAQF,MAAa,iBACX,MACA,MACA,YAC6C;CAC7C,MAAM;CACN,MAAM;EAAE;EAAM;CAAK;CAGnB,QAAQ,OAAO,YACb,OAAO,IAAI;EACT,WAAW;GACT,MAAM,UAAU,cAAc,QAAQ,IAAI;GAC1C,IAAI,YAAY,MAAM,MAAM,IAAI,MAAM,0BAA0B;GAChE,IAAI;IACF,QAAQ,YAAY,IAAI;GAC1B,UAAU;IACR,QAAQ,MAAM;GAChB;EACF;EACA,OAAO;CACT,CAAC,GACD;EACE,YAAW,YAAW,OAAO,QAAQ,iBAAiB,gBAAgB,EAAE,QAAQ,CAAC,CAAC;EAClF,iBAAiB,OAAO,QAAQ,iBAAiB,OAAO,CAAC;CAC3D,CACF;AACF"}

package/dist/net/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./broadcast.js";
+export * from "./online.js";
+export * from "./sharedHost.js";
+export * from "./sse.js";
+export * from "./websocket.js";

package/dist/net/index.js

@@ -0,0 +1,6 @@
+export * from "./broadcast.js";
+export * from "./online.js";
+export * from "./sharedHost.js";
+export * from "./sse.js";
+export * from "./websocket.js";
+export {};