foldkit-primitives 0.15.4 → 0.16.0

package/dist/dom/track-box.js

@@ -0,0 +1,131 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/dom/track-box.ts
+/** The attribute on the mounted element naming the element `TrackBox` follows, by id. */
+const TRACK_TARGET_ATTRIBUTE = "data-target";
+/** The custom properties `TrackBox` writes for `name`, as `measured` names `Measure`'s. */
+const trackedBox = (name) => ({
+	x: `--fk-${name}-x`,
+	y: `--fk-${name}-y`,
+	w: `--fk-${name}-w`,
+	h: `--fk-${name}-h`,
+	radius: `--fk-${name}-radius`
+});
+/** Sent as the followed element changes: its id, and whether it is on the page. */
+const TrackedTarget = Schema.TaggedStruct("TrackedTarget", {
+	target: Schema.String,
+	found: Schema.Boolean
+});
+/**
+* The radius a box of `width` by `height` draws for a computed
+* `border-top-left-radius` of `value` (`8px`, `50%`, `8px 4px`): its
+* horizontal length in pixels, a share of the width for a percentage, and
+* never more than half the shorter side, where the browser stops it.
+*/
+const cornerRadius = (value, width, height) => {
+	const first = value.trim().split(/\s+/)[0] ?? "";
+	const length = parseFloat(first);
+	if (!Number.isFinite(length)) return 0;
+	const pixels = first.endsWith("%") ? length * width / 100 : length;
+	return Math.max(0, Math.min(pixels, width / 2, height / 2));
+};
+/**
+* Follows another element's box, as a Mount: the element whose id is the
+* mounted element's `data-target` (`TRACK_TARGET_ATTRIBUTE`). Its box in
+* viewport pixels is written on the mounted element as `--fk-<name>-x`,
+* `-y`, `-w` and `-h`, and with `radius`, its top left corner's radius as
+* `--fk-<name>-radius` (`cornerRadius`), so a fixed overlay drawn from them
+* (a tour's cutout, a coach mark's ring) sits over it. While nothing is
+* followed they are removed, so a stylist's fallbacks apply.
+*
+* The box is read again on a scroll anywhere (heard on the way down, since
+* `scroll` does not bubble), a window resize, the followed element's own
+* resize, and any change to the document's elements, which is also how a
+* target drawn anew under the same id is found. `data-target` is read again
+* whenever it changes, so one element can glide from target to target
+* without being drawn again, which a Mount's args, read once, could not do.
+* What moves the target by any other way (a stylesheet added) is seen at the
+* next of these.
+*
+* Whether a target is on the page is the parent's to act on (a tour shows
+* the step in the middle instead), so each change of the target or of
+* whether it is found sends `TrackedTarget`, starting with the first one.
+* Since it sends a Message, a component may draw it by default: a Scene test
+* resolves it with what the parent maps it to. An empty `data-target` follows
+* nothing and sends nothing.
+*/
+const TrackBox = Mount.defineStream("TrackBox", {
+	messages: [TrackedTarget],
+	args: {
+		/** The custom properties' prefix: `tour` writes `--fk-tour-x`. */
+		name: Schema.String,
+		/** Whether to write the target's corner radius too; it reads the target's computed style. */
+		radius: Schema.optional(Schema.Boolean)
+	},
+	execute: ({ element, name, radius = false }) => Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const document = element.ownerDocument;
+		const view = document.defaultView;
+		const properties = trackedBox(name);
+		const style = element instanceof HTMLElement ? element.style : void 0;
+		let target = null;
+		let told;
+		const place = () => {
+			if (style === void 0) return;
+			if (target === null) {
+				for (const property of Object.values(properties)) style.removeProperty(property);
+				return;
+			}
+			const box = target.getBoundingClientRect();
+			style.setProperty(properties.x, `${box.left}px`);
+			style.setProperty(properties.y, `${box.top}px`);
+			style.setProperty(properties.w, `${box.width}px`);
+			style.setProperty(properties.h, `${box.height}px`);
+			if (radius) {
+				const corner = getComputedStyle(target).borderTopLeftRadius;
+				style.setProperty(properties.radius, `${cornerRadius(corner, box.width, box.height)}px`);
+			}
+		};
+		const follow = () => {
+			const id = element.getAttribute("data-target") ?? "";
+			const found = id === "" ? null : document.getElementById(id);
+			if (found !== target) {
+				if (target !== null) resized.unobserve(target);
+				if (found !== null) resized.observe(found);
+				target = found;
+			}
+			place();
+			if (id !== "" && (told?.target !== id || told.found !== (found !== null))) {
+				told = TrackedTarget.make({
+					target: id,
+					found: found !== null
+				});
+				Queue.offerUnsafe(queue, told);
+			}
+		};
+		const resized = new ResizeObserver(place);
+		const changed = new MutationObserver(follow);
+		changed.observe(element, {
+			attributes: true,
+			attributeFilter: [TRACK_TARGET_ATTRIBUTE]
+		});
+		changed.observe(document, {
+			childList: true,
+			subtree: true
+		});
+		view?.addEventListener("scroll", place, {
+			capture: true,
+			passive: true
+		});
+		view?.addEventListener("resize", place);
+		follow();
+		return () => {
+			changed.disconnect();
+			resized.disconnect();
+			view?.removeEventListener("scroll", place, { capture: true });
+			view?.removeEventListener("resize", place);
+		};
+	}), (stop) => Effect.sync(stop)))
+});
+export { TRACK_TARGET_ATTRIBUTE, TrackBox, TrackedTarget, cornerRadius, trackedBox };
+
+//# sourceMappingURL=track-box.js.map

package/dist/dom/track-box.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-box.js","names":[],"sources":["../../src/dom/track-box.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\n/** The attribute on the mounted element naming the element `TrackBox` follows, by id. */\nexport const TRACK_TARGET_ATTRIBUTE = 'data-target'\n\n/** The custom properties `TrackBox` writes for `name`, as `measured` names `Measure`'s. */\nexport const trackedBox = (name: string) =>\n  ({\n    x: `--fk-${name}-x`,\n    y: `--fk-${name}-y`,\n    w: `--fk-${name}-w`,\n    h: `--fk-${name}-h`,\n    radius: `--fk-${name}-radius`,\n  }) as const\n\n/** Sent as the followed element changes: its id, and whether it is on the page. */\nexport const TrackedTarget = Schema.TaggedStruct('TrackedTarget', {\n  target: Schema.String,\n  found: Schema.Boolean,\n})\nexport type TrackedTarget = typeof TrackedTarget.Type\n\n/**\n * The radius a box of `width` by `height` draws for a computed\n * `border-top-left-radius` of `value` (`8px`, `50%`, `8px 4px`): its\n * horizontal length in pixels, a share of the width for a percentage, and\n * never more than half the shorter side, where the browser stops it.\n */\nexport const cornerRadius = (value: string, width: number, height: number): number => {\n  const first = value.trim().split(/\\s+/)[0] ?? ''\n  const length = parseFloat(first)\n  if (!Number.isFinite(length)) return 0\n  const pixels = first.endsWith('%') ? (length * width) / 100 : length\n  return Math.max(0, Math.min(pixels, width / 2, height / 2))\n}\n\n/**\n * Follows another element's box, as a Mount: the element whose id is the\n * mounted element's `data-target` (`TRACK_TARGET_ATTRIBUTE`). Its box in\n * viewport pixels is written on the mounted element as `--fk-<name>-x`,\n * `-y`, `-w` and `-h`, and with `radius`, its top left corner's radius as\n * `--fk-<name>-radius` (`cornerRadius`), so a fixed overlay drawn from them\n * (a tour's cutout, a coach mark's ring) sits over it. While nothing is\n * followed they are removed, so a stylist's fallbacks apply.\n *\n * The box is read again on a scroll anywhere (heard on the way down, since\n * `scroll` does not bubble), a window resize, the followed element's own\n * resize, and any change to the document's elements, which is also how a\n * target drawn anew under the same id is found. `data-target` is read again\n * whenever it changes, so one element can glide from target to target\n * without being drawn again, which a Mount's args, read once, could not do.\n * What moves the target by any other way (a stylesheet added) is seen at the\n * next of these.\n *\n * Whether a target is on the page is the parent's to act on (a tour shows\n * the step in the middle instead), so each change of the target or of\n * whether it is found sends `TrackedTarget`, starting with the first one.\n * Since it sends a Message, a component may draw it by default: a Scene test\n * resolves it with what the parent maps it to. An empty `data-target` follows\n * nothing and sends nothing.\n */\nexport const TrackBox = Mount.defineStream('TrackBox', {\n  messages: [TrackedTarget],\n  args: {\n    /** The custom properties' prefix: `tour` writes `--fk-tour-x`. */\n    name: Schema.String,\n    /** Whether to write the target's corner radius too; it reads the target's computed style. */\n    radius: Schema.optional(Schema.Boolean),\n  },\n  execute: ({ element, name, radius = false }) =>\n    Stream.callback<TrackedTarget>(queue =>\n      Effect.acquireRelease(\n        Effect.sync(() => {\n          const document = element.ownerDocument\n          const view = document.defaultView\n          const properties = trackedBox(name)\n          const style = element instanceof HTMLElement ? element.style : undefined\n          let target: Element | null = null\n          let told: TrackedTarget | undefined\n\n          const place = () => {\n            if (style === undefined) return\n            if (target === null) {\n              for (const property of Object.values(properties)) style.removeProperty(property)\n              return\n            }\n            const box = target.getBoundingClientRect()\n            style.setProperty(properties.x, `${box.left}px`)\n            style.setProperty(properties.y, `${box.top}px`)\n            style.setProperty(properties.w, `${box.width}px`)\n            style.setProperty(properties.h, `${box.height}px`)\n            if (radius) {\n              const corner = getComputedStyle(target).borderTopLeftRadius\n              style.setProperty(\n                properties.radius,\n                `${cornerRadius(corner, box.width, box.height)}px`,\n              )\n            }\n          }\n          // Looks the target up again, telling the parent when what it follows, or whether\n          // that is found, changed.\n          const follow = () => {\n            const id = element.getAttribute(TRACK_TARGET_ATTRIBUTE) ?? ''\n            const found = id === '' ? null : document.getElementById(id)\n            if (found !== target) {\n              if (target !== null) resized.unobserve(target)\n              if (found !== null) resized.observe(found)\n              target = found\n            }\n            place()\n            if (id !== '' && (told?.target !== id || told.found !== (found !== null))) {\n              told = TrackedTarget.make({ target: id, found: found !== null })\n              Queue.offerUnsafe(queue, told)\n            }\n          }\n\n          // Every observer is made before any observes, so one that throws (jsdom has no\n          // ResizeObserver) leaves nothing attached.\n          const resized = new ResizeObserver(place)\n          const changed = new MutationObserver(follow)\n          changed.observe(element, {\n            attributes: true,\n            attributeFilter: [TRACK_TARGET_ATTRIBUTE],\n          })\n          changed.observe(document, { childList: true, subtree: true })\n          view?.addEventListener('scroll', place, { capture: true, passive: true })\n          view?.addEventListener('resize', place)\n          follow()\n          return () => {\n            changed.disconnect()\n            resized.disconnect()\n            view?.removeEventListener('scroll', place, { capture: true })\n            view?.removeEventListener('resize', place)\n          }\n        }),\n        stop => Effect.sync(stop),\n      ),\n    ),\n})\n"],"mappings":"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"}

package/dist/events/active-element.d.ts

@@ -0,0 +1,15 @@
+import { Schema, Stream } from "effect";
+export declare const ActiveElementMessage: import("foldkit/message").MessageUnion<{
+  readonly Changed: {
+    tag: Schema.String;
+    id: Schema.NullOr<Schema.String>;
+  };
+}>;
+export type ActiveElementMessage = typeof ActiveElementMessage.Type;
+/**
+ * Focus changes on the document. Without a document the stream is empty
+ * instead of throwing. Lift with `Subscription.persistentEntry`, mapping into
+ * the parent's Message.
+ */
+export declare const activeElementEvents: () => Stream.Stream<ActiveElementMessage>;
+//# sourceMappingURL=active-element.d.ts.map

package/dist/events/active-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-element.d.ts","names":[],"sources":["../../src/events/active-element.ts"],"mappings":";qBASa,gDAAoB;;IACpB,KAAG,OAAA;IAAiB,IAAE,OAAA,OAAA,OAAA;;;YAEvB,8BAA8B,qBAAqB;;;;;;qBAOlD,2BAA0B,OAAO,OAAO"}

package/dist/events/active-element.js

@@ -0,0 +1,33 @@
+import { Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/events/active-element.ts
+/**
+* Focused element as an entry — not a bundle, because elements are not
+* Model facts: this reports the active element's tag and id (both
+* serializable), and the parent stores what matters. Starts with the
+* current answer, then follows `focusin`/`focusout`.
+*/
+const ActiveElementMessage = defineMessageUnion({ Changed: {
+	tag: Schema.String,
+	id: Schema.NullOr(Schema.String)
+} });
+/**
+* Focus changes on the document. Without a document the stream is empty
+* instead of throwing. Lift with `Subscription.persistentEntry`, mapping into
+* the parent's Message.
+*/
+const activeElementEvents = () => {
+	if (typeof document === "undefined") return Stream.empty;
+	const read = () => {
+		const element = document.activeElement;
+		return ActiveElementMessage.Changed({
+			tag: element?.tagName ?? "",
+			id: element?.id !== void 0 && element.id !== "" ? element.id : null
+		});
+	};
+	const changes = Stream.mergeAll([Stream.fromEventListener(document, "focusin").pipe(Stream.map(read)), Stream.fromEventListener(document, "focusout").pipe(Stream.map(read))], { concurrency: "unbounded" });
+	return Stream.concat(Stream.make(read()), changes);
+};
+export { ActiveElementMessage, activeElementEvents };
+
+//# sourceMappingURL=active-element.js.map

package/dist/events/active-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-element.js","names":[],"sources":["../../src/events/active-element.ts"],"sourcesContent":["/**\n * Focused element as an entry — not a bundle, because elements are not\n * Model facts: this reports the active element's tag and id (both\n * serializable), and the parent stores what matters. Starts with the\n * current answer, then follows `focusin`/`focusout`.\n */\nimport { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ActiveElementMessage = defineMessageUnion({\n  Changed: { tag: Schema.String, id: Schema.NullOr(Schema.String) },\n})\nexport type ActiveElementMessage = typeof ActiveElementMessage.Type\n\n/**\n * Focus changes on the document. Without a document the stream is empty\n * instead of throwing. Lift with `Subscription.persistentEntry`, mapping into\n * the parent's Message.\n */\nexport const activeElementEvents = (): Stream.Stream<ActiveElementMessage> => {\n  if (typeof document === 'undefined') return Stream.empty\n  const read = (): ActiveElementMessage => {\n    const element = document.activeElement as Element | null | undefined\n    return ActiveElementMessage.Changed({\n      tag: element?.tagName ?? '',\n      id: element?.id !== undefined && element.id !== '' ? element.id : null,\n    })\n  }\n  const changes: Stream.Stream<ActiveElementMessage> = Stream.mergeAll(\n    [\n      Stream.fromEventListener(document, 'focusin').pipe(Stream.map(read)),\n      Stream.fromEventListener(document, 'focusout').pipe(Stream.map(read)),\n    ],\n    { concurrency: 'unbounded' },\n  )\n  return Stream.concat(Stream.make(read()), changes)\n}\n"],"mappings":";;;;;;;;;AASA,MAAa,uBAAuB,mBAAmB,EACrD,SAAS;CAAE,KAAK,OAAO;CAAQ,IAAI,OAAO,OAAO,OAAO,MAAM;AAAE,EAClE,CAAC;;;;;;AAQD,MAAa,4BAAiE;CAC5E,IAAI,OAAO,aAAa,aAAa,OAAO,OAAO;CACnD,MAAM,aAAmC;EACvC,MAAM,UAAU,SAAS;EACzB,OAAO,qBAAqB,QAAQ;GAClC,KAAK,SAAS,WAAW;GACzB,IAAI,SAAS,OAAO,KAAA,KAAa,QAAQ,OAAO,KAAK,QAAQ,KAAK;EACpE,CAAC;CACH;CACA,MAAM,UAA+C,OAAO,SAC1D,CACE,OAAO,kBAAkB,UAAU,SAAS,CAAC,CAAC,KAAK,OAAO,IAAI,IAAI,CAAC,GACnE,OAAO,kBAAkB,UAAU,UAAU,CAAC,CAAC,KAAK,OAAO,IAAI,IAAI,CAAC,CACtE,GACA,EAAE,aAAa,YAAY,CAC7B;CACA,OAAO,OAAO,OAAO,OAAO,KAAK,KAAK,CAAC,GAAG,OAAO;AACnD"}

package/dist/events/hotkeys.d.ts

@@ -0,0 +1,22 @@
+export interface KeyPress {
+  readonly key: string;
+  readonly repeat: boolean;
+  readonly ctrl: boolean;
+  readonly shift: boolean;
+  readonly alt: boolean;
+  readonly meta: boolean;
+}
+/**
+ * Hotkey matching as a pure function over a `Pressed` payload: `matchHotkey`
+ * answers whether a press is the shortcut, so `update` stays a table of
+ * chords instead of a nest of modifier checks. Patterns read like
+ * `"ctrl+shift+k"`: modifiers first (any order), the key last,
+ * case-insensitive, with `cmd`/`command` and `option` as the Mac names for
+ * meta and alt. Matching is exact — unlisted modifiers must be up — and
+ * auto-repeat never matches, so holding a chord fires once. `space` (or a
+ * bare space) means the space key; `esc` means escape. A pattern with
+ * no key, or two keys, matches nothing: predicates return false, they do
+ * not throw on the hot path.
+ */
+export declare const matchHotkey: (pattern: string, press: KeyPress) => boolean;
+//# sourceMappingURL=hotkeys.d.ts.map

package/dist/events/hotkeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotkeys.d.ts","names":[],"sources":["../../src/events/hotkeys.ts"],"mappings":"A,iBAAiB;WACN;WACA;WACA;WACA;WACA;WACA;;;;;;;;;;;;;;qBA8CE,cAAW,iBAAmB,OAAS"}

package/dist/events/hotkeys.js

@@ -0,0 +1,56 @@
+// src/events/hotkeys.ts
+const modifierOf = (part) => {
+	switch (part) {
+		case "ctrl":
+		case "control": return "ctrl";
+		case "shift": return "shift";
+		case "alt":
+		case "option": return "alt";
+		case "meta":
+		case "cmd":
+		case "command": return "meta";
+		default: return null;
+	}
+};
+const keyNameOf = (part) => {
+	switch (part) {
+		case "spacebar":
+		case " ": return "space";
+		case "esc": return "escape";
+		default: return part;
+	}
+};
+/**
+* Hotkey matching as a pure function over a `Pressed` payload: `matchHotkey`
+* answers whether a press is the shortcut, so `update` stays a table of
+* chords instead of a nest of modifier checks. Patterns read like
+* `"ctrl+shift+k"`: modifiers first (any order), the key last,
+* case-insensitive, with `cmd`/`command` and `option` as the Mac names for
+* meta and alt. Matching is exact — unlisted modifiers must be up — and
+* auto-repeat never matches, so holding a chord fires once. `space` (or a
+* bare space) means the space key; `esc` means escape. A pattern with
+* no key, or two keys, matches nothing: predicates return false, they do
+* not throw on the hot path.
+*/
+const matchHotkey = (pattern, press) => {
+	if (press.repeat) return false;
+	const trimmed = pattern.split("+").map((part) => part.trim().toLowerCase()).filter((part) => part !== "");
+	const parts = trimmed.length === 0 && pattern.length > 0 ? ["space"] : trimmed;
+	const keys = parts.filter((part) => modifierOf(part) === null);
+	if (keys.length !== 1) return false;
+	if (keyNameOf(keys[0]) !== keyNameOf(press.key.toLowerCase())) return false;
+	const required = {
+		ctrl: false,
+		shift: false,
+		alt: false,
+		meta: false
+	};
+	for (const part of parts) {
+		const modifier = modifierOf(part);
+		if (modifier !== null) required[modifier] = true;
+	}
+	return required.ctrl === press.ctrl && required.shift === press.shift && required.alt === press.alt && required.meta === press.meta;
+};
+export { matchHotkey };
+
+//# sourceMappingURL=hotkeys.js.map

package/dist/events/hotkeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotkeys.js","names":[],"sources":["../../src/events/hotkeys.ts"],"sourcesContent":["export interface KeyPress {\n  readonly key: string\n  readonly repeat: boolean\n  readonly ctrl: boolean\n  readonly shift: boolean\n  readonly alt: boolean\n  readonly meta: boolean\n}\n\nconst modifierOf = (part: string): 'ctrl' | 'shift' | 'alt' | 'meta' | null => {\n  switch (part) {\n    case 'ctrl':\n    case 'control':\n      return 'ctrl'\n    case 'shift':\n      return 'shift'\n    case 'alt':\n    case 'option':\n      return 'alt'\n    case 'meta':\n    case 'cmd':\n    case 'command':\n      return 'meta'\n    default:\n      return null\n  }\n}\n\nconst keyNameOf = (part: string): string => {\n  switch (part) {\n    case 'spacebar':\n    case ' ':\n      return 'space'\n    case 'esc':\n      return 'escape'\n    default:\n      return part\n  }\n}\n\n/**\n * Hotkey matching as a pure function over a `Pressed` payload: `matchHotkey`\n * answers whether a press is the shortcut, so `update` stays a table of\n * chords instead of a nest of modifier checks. Patterns read like\n * `\"ctrl+shift+k\"`: modifiers first (any order), the key last,\n * case-insensitive, with `cmd`/`command` and `option` as the Mac names for\n * meta and alt. Matching is exact — unlisted modifiers must be up — and\n * auto-repeat never matches, so holding a chord fires once. `space` (or a\n * bare space) means the space key; `esc` means escape. A pattern with\n * no key, or two keys, matches nothing: predicates return false, they do\n * not throw on the hot path.\n */\nexport const matchHotkey = (pattern: string, press: KeyPress): boolean => {\n  if (press.repeat) return false\n  const trimmed = pattern\n    .split('+')\n    .map(part => part.trim().toLowerCase())\n    .filter(part => part !== '')\n  // A bare whitespace pattern means the space key; an empty pattern is malformed.\n  const parts = trimmed.length === 0 && pattern.length > 0 ? ['space'] : trimmed\n  const keys = parts.filter(part => modifierOf(part) === null)\n  if (keys.length !== 1) return false\n  if (keyNameOf(keys[0]!) !== keyNameOf(press.key.toLowerCase())) return false\n  const required: Record<'ctrl' | 'shift' | 'alt' | 'meta', boolean> = {\n    ctrl: false,\n    shift: false,\n    alt: false,\n    meta: false,\n  }\n  for (const part of parts) {\n    const modifier = modifierOf(part)\n    if (modifier !== null) required[modifier] = true\n  }\n  return (\n    required.ctrl === press.ctrl &&\n    required.shift === press.shift &&\n    required.alt === press.alt &&\n    required.meta === press.meta\n  )\n}\n"],"mappings":";AASA,MAAM,cAAc,SAA2D;CAC7E,QAAQ,MAAR;EACE,KAAK;EACL,KAAK,WACH,OAAO;EACT,KAAK,SACH,OAAO;EACT,KAAK;EACL,KAAK,UACH,OAAO;EACT,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAEA,MAAM,aAAa,SAAyB;CAC1C,QAAQ,MAAR;EACE,KAAK;EACL,KAAK,KACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;;;;;;;;AAcA,MAAa,eAAe,SAAiB,UAA6B;CACxE,IAAI,MAAM,QAAQ,OAAO;CACzB,MAAM,UAAU,QACb,MAAM,GAAG,CAAC,CACV,KAAI,SAAQ,KAAK,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CACtC,QAAO,SAAQ,SAAS,EAAE;CAE7B,MAAM,QAAQ,QAAQ,WAAW,KAAK,QAAQ,SAAS,IAAI,CAAC,OAAO,IAAI;CACvE,MAAM,OAAO,MAAM,QAAO,SAAQ,WAAW,IAAI,MAAM,IAAI;CAC3D,IAAI,KAAK,WAAW,GAAG,OAAO;CAC9B,IAAI,UAAU,KAAK,EAAG,MAAM,UAAU,MAAM,IAAI,YAAY,CAAC,GAAG,OAAO;CACvE,MAAM,WAA+D;EACnE,MAAM;EACN,OAAO;EACP,KAAK;EACL,MAAM;CACR;CACA,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,WAAW,WAAW,IAAI;EAChC,IAAI,aAAa,MAAM,SAAS,YAAY;CAC9C;CACA,OACE,SAAS,SAAS,MAAM,QACxB,SAAS,UAAU,MAAM,SACzB,SAAS,QAAQ,MAAM,OACvB,SAAS,SAAS,MAAM;AAE5B"}

package/dist/events/idle.d.ts

@@ -0,0 +1,29 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const IdleModel: Schema.Struct<{
+  readonly idle: Schema.Boolean;
+}>;
+export type IdleModel = typeof IdleModel.Type;
+export declare const IdleMessage: import("foldkit/message").MessageUnion<{
+  readonly BecameIdle: {};
+  readonly BecameActive: {};
+}>;
+export type IdleMessage = typeof IdleMessage.Type;
+/**
+ * Idleness as a bundle: `idle` in the Model, flipped by activity and
+ * silence. While active, activity debounced past `timeoutMs` settles to
+ * `BecameIdle`; while idle, the first activity wakes to `BecameActive` and
+ * the dependency flip restarts the watch. Starts active — a lurker idles
+ * when the timeout elapses. The clock is Effect's, so tests drive it with
+ * TestClock.
+ */
+export declare const Idle: Bundle.Bundle<"Idle", {
+  readonly timeoutMs: number;
+}, {
+  readonly idle: boolean;
+}, {
+  readonly _tag: "BecameActive";
+} | {
+  readonly _tag: "BecameIdle";
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=idle.d.ts.map

package/dist/events/idle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle.d.ts","names":[],"sources":["../../src/events/idle.ts"],"mappings":";;qBAMa,WAAS,OAAA;;;YACV,mBAAmB,UAAU;qBAE5B,uCAAW;;;;YACZ,qBAAqB,YAAY;;;;;;;;;qBAsBhC,MAAI,OAAA"}

package/dist/events/idle.js

@@ -0,0 +1,51 @@
+import { Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+// src/events/idle.ts
+const IdleModel = Schema.Struct({ idle: Schema.Boolean });
+const IdleMessage = defineMessageUnion({
+	BecameIdle: {},
+	BecameActive: {}
+});
+const activity = () => {
+	if (typeof window === "undefined") return Stream.empty;
+	const senses = [
+		Stream.fromEventListener(window, "mousemove"),
+		Stream.fromEventListener(window, "keydown"),
+		Stream.fromEventListener(window, "pointerdown"),
+		Stream.fromEventListener(window, "scroll")
+	];
+	return Stream.mergeAll(senses, { concurrency: "unbounded" });
+};
+/**
+* Idleness as a bundle: `idle` in the Model, flipped by activity and
+* silence. While active, activity debounced past `timeoutMs` settles to
+* `BecameIdle`; while idle, the first activity wakes to `BecameActive` and
+* the dependency flip restarts the watch. Starts active — a lurker idles
+* when the timeout elapses. The clock is Effect's, so tests drive it with
+* TestClock.
+*/
+const Idle = Bundle.make("Idle", {
+	Model: IdleModel,
+	Message: IdleMessage,
+	args: Schema.Struct({ timeoutMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
+	init: () => ({ model: { idle: false } }),
+	update: (model, message) => IdleMessage.match(message, {
+		BecameIdle: () => model.idle ? { model } : { model: {
+			...model,
+			idle: true
+		} },
+		BecameActive: () => model.idle ? { model: {
+			...model,
+			idle: false
+		} } : { model }
+	}),
+	subscriptions: ({ timeoutMs }) => Subscription.make()((entry) => ({ watch: entry({ idle: Schema.Boolean }, {
+		modelToDependencies: (model) => ({ idle: model.idle }),
+		dependenciesToStream: ({ idle }) => idle ? activity().pipe(Stream.take(1), Stream.map(() => IdleMessage.BecameActive())) : Stream.concat(Stream.make(null), activity()).pipe(Stream.debounce(timeoutMs), Stream.map(() => IdleMessage.BecameIdle()))
+	}) }))
+});
+export { Idle, IdleMessage, IdleModel };
+
+//# sourceMappingURL=idle.js.map

package/dist/events/idle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle.js","names":[],"sources":["../../src/events/idle.ts"],"sourcesContent":["import { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\n\nexport const IdleModel = Schema.Struct({ idle: Schema.Boolean })\nexport type IdleModel = typeof IdleModel.Type\n\nexport const IdleMessage = defineMessageUnion({ BecameIdle: {}, BecameActive: {} })\nexport type IdleMessage = typeof IdleMessage.Type\n\nconst activity = (): Stream.Stream<unknown> => {\n  if (typeof window === 'undefined') return Stream.empty\n  // One stream per sense; the merge fans into the debounce below.\n  const senses: Array<Stream.Stream<unknown>> = [\n    Stream.fromEventListener(window, 'mousemove'),\n    Stream.fromEventListener(window, 'keydown'),\n    Stream.fromEventListener(window, 'pointerdown'),\n    Stream.fromEventListener(window, 'scroll'),\n  ]\n  return Stream.mergeAll(senses, { concurrency: 'unbounded' })\n}\n\n/**\n * Idleness as a bundle: `idle` in the Model, flipped by activity and\n * silence. While active, activity debounced past `timeoutMs` settles to\n * `BecameIdle`; while idle, the first activity wakes to `BecameActive` and\n * the dependency flip restarts the watch. Starts active — a lurker idles\n * when the timeout elapses. The clock is Effect's, so tests drive it with\n * TestClock.\n */\nexport const Idle = Bundle.make('Idle', {\n  Model: IdleModel,\n  Message: IdleMessage,\n  args: Schema.Struct({\n    timeoutMs: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n  }),\n  init: () => ({ model: { idle: false } }),\n  update: (model, message) =>\n    IdleMessage.match<Update.ReturnWithOutMessage<IdleModel, IdleMessage, never>>(message, {\n      // One already in flight when the watch restarts can repeat the state.\n      BecameIdle: () => (model.idle ? { model } : { model: { ...model, idle: true } }),\n      BecameActive: () => (model.idle ? { model: { ...model, idle: false } } : { model }),\n    }),\n  subscriptions: ({ timeoutMs }): Subscription.Subscriptions<IdleModel, IdleMessage> =>\n    Subscription.make<IdleModel, IdleMessage>()(entry => ({\n      watch: entry(\n        { idle: Schema.Boolean },\n        {\n          modelToDependencies: model => ({ idle: model.idle }),\n          dependenciesToStream: ({ idle }) =>\n            idle\n              ? activity().pipe(\n                  Stream.take(1),\n                  Stream.map(() => IdleMessage.BecameActive()),\n                )\n              : // Seeded with subscribe time as last-known-alive: silence from\n                // here still settles, so a lurker idles without moving first.\n                Stream.concat(Stream.make(null), activity()).pipe(\n                  Stream.debounce(timeoutMs),\n                  Stream.map(() => IdleMessage.BecameIdle()),\n                ),\n        },\n      ),\n    })),\n})\n"],"mappings":";;;;;AAMA,MAAa,YAAY,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,CAAC;AAG/D,MAAa,cAAc,mBAAmB;CAAE,YAAY,CAAC;CAAG,cAAc,CAAC;AAAE,CAAC;AAGlF,MAAM,iBAAyC;CAC7C,IAAI,OAAO,WAAW,aAAa,OAAO,OAAO;CAEjD,MAAM,SAAwC;EAC5C,OAAO,kBAAkB,QAAQ,WAAW;EAC5C,OAAO,kBAAkB,QAAQ,SAAS;EAC1C,OAAO,kBAAkB,QAAQ,aAAa;EAC9C,OAAO,kBAAkB,QAAQ,QAAQ;CAC3C;CACA,OAAO,OAAO,SAAS,QAAQ,EAAE,aAAa,YAAY,CAAC;AAC7D;;;;;;;;;AAUA,MAAa,OAAO,OAAO,KAAK,QAAQ;CACtC,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO,EAClB,WAAW,OAAO,OAAO,KACvB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC,EACF,CAAC;CACD,aAAa,EAAE,OAAO,EAAE,MAAM,MAAM,EAAE;CACtC,SAAS,OAAO,YACd,YAAY,MAAkE,SAAS;EAErF,kBAAmB,MAAM,OAAO,EAAE,MAAM,IAAI,EAAE,OAAO;GAAE,GAAG;GAAO,MAAM;EAAK,EAAE;EAC9E,oBAAqB,MAAM,OAAO,EAAE,OAAO;GAAE,GAAG;GAAO,MAAM;EAAM,EAAE,IAAI,EAAE,MAAM;CACnF,CAAC;CACH,gBAAgB,EAAE,gBAChB,aAAa,KAA6B,CAAC,EAAC,WAAU,EACpD,OAAO,MACL,EAAE,MAAM,OAAO,QAAQ,GACvB;EACE,sBAAqB,WAAU,EAAE,MAAM,MAAM,KAAK;EAClD,uBAAuB,EAAE,WACvB,OACI,SAAS,CAAC,CAAC,KACT,OAAO,KAAK,CAAC,GACb,OAAO,UAAU,YAAY,aAAa,CAAC,CAC7C,IAGA,OAAO,OAAO,OAAO,KAAK,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,KAC3C,OAAO,SAAS,SAAS,GACzB,OAAO,UAAU,YAAY,WAAW,CAAC,CAC3C;CACR,CACF,EACF,EAAE;AACN,CAAC"}

package/dist/events/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./active-element.js";
+export * from "./hotkeys.js";
+export * from "./idle.js";
+export * from "./input-modality.js";
+export * from "./keyboard.js";
+export * from "./pointer.js";
+export * from "./scroll.js";
+export * from "./visibility.js";
+export * from "./window-size.js";

package/dist/events/index.js

@@ -0,0 +1,10 @@
+export * from "./active-element.js";
+export * from "./hotkeys.js";
+export * from "./idle.js";
+export * from "./input-modality.js";
+export * from "./keyboard.js";
+export * from "./pointer.js";
+export * from "./scroll.js";
+export * from "./visibility.js";
+export * from "./window-size.js";
+export {};

package/dist/{input-modality-l7InESYh.d.mts → events/input-modality.d.ts}

@@ -1,19 +1,19 @@
 import { Schema } from "effect";
 import { Bundle } from "foldkit-bundle";
-declare const Modality: Schema.Literals<readonly ["keyboard", "pointer", "unknown"]>;
-type Modality = typeof Modality.Type;
-declare const InputModalityModel: Schema.Struct<{
+export declare const Modality: Schema.Literals<readonly ["keyboard", "pointer", "unknown"]>;
+export type Modality = typeof Modality.Type;
+export declare const InputModalityModel: Schema.Struct<{
   readonly modality: Schema.Literals<readonly ["keyboard", "pointer", "unknown"]>;
 }>;
-type InputModalityModel = typeof InputModalityModel.Type;
-declare const InputModalityMessage: import("foldkit/message").MessageUnion<{
+export type InputModalityModel = typeof InputModalityModel.Type;
+export declare const InputModalityMessage: import("foldkit/message").MessageUnion<{
   readonly Changed: {
     modality: Schema.Literals<readonly ["keyboard", "pointer", "unknown"]>;
   };
 }>;
-type InputModalityMessage = typeof InputModalityMessage.Type;
+export type InputModalityMessage = typeof InputModalityMessage.Type;
 /** A modifier alone says nothing about how the page is being driven. */
-declare const modalityOfKey: (key: string) => Modality | null;
+export declare const modalityOfKey: (key: string) => Modality | null;
 /**
  * Input modality as a bundle: whether the user last drove the page by
  * keyboard or by pointer. The browser reports the facts; the Model keeps the
@@ -21,11 +21,10 @@ declare const modalityOfKey: (key: string) => Modality | null;
  * reading the DOM, and a replay sees the same answer. CSS `:focus-visible`
  * is the floor; this is for JavaScript that must know.
  */
-declare const InputModality: Bundle.Bundle<"InputModality", void, {
+export declare const InputModality: Bundle.Bundle<"InputModality", void, {
   readonly modality: "keyboard" | "pointer" | "unknown";
 }, {
   readonly _tag: "Changed";
   readonly modality: "keyboard" | "pointer" | "unknown";
 }, never, never, never, void, {}, {}>;
-export { modalityOfKey as a, Modality as i, InputModalityMessage as n, InputModalityModel as r, InputModality as t };
-//# sourceMappingURL=input-modality-l7InESYh.d.mts.map
+//# sourceMappingURL=input-modality.d.ts.map

package/dist/events/input-modality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-modality.d.ts","names":[],"sources":["../../src/events/input-modality.ts"],"mappings":";;qBAKa,UAAQ,OAAA;YACT,kBAAkB,SAAS;qBAE1B,oBAAkB,OAAA;;;YACnB,4BAA4B,mBAAmB;qBAE9C,gDAAoB;;IAAmC,UAAQ,OAAA;;;YAChE,8BAA8B,qBAAqB;;qBAKlD,gBAAa,gBAAkB;;;;;;;;qBA0B/B,eAAa,OAAA"}

package/dist/{input-modality-XwQOFLip.mjs → events/input-modality.js}

@@ -37,6 +37,6 @@ const InputModality = Bundle.make("InputModality", {
 	update: (model, message) => model.modality === message.modality ? { model } : { model: { modality: message.modality } },
 	subscriptions: () => Subscription.make()(() => ({ changes: Subscription.persistentEntry(modalityStream()) }))
 });
-export { modalityOfKey as a, Modality as i, InputModalityMessage as n, InputModalityModel as r, InputModality as t };
+export { InputModality, InputModalityMessage, InputModalityModel, Modality, modalityOfKey };
 
-//# sourceMappingURL=input-modality-XwQOFLip.mjs.map
+//# sourceMappingURL=input-modality.js.map

package/dist/events/input-modality.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-modality.js","names":[],"sources":["../../src/events/input-modality.ts"],"sourcesContent":["import { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport { Bundle } from 'foldkit-bundle'\n\nexport const Modality = Schema.Literals(['keyboard', 'pointer', 'unknown'])\nexport type Modality = typeof Modality.Type\n\nexport const InputModalityModel = Schema.Struct({ modality: Modality })\nexport type InputModalityModel = typeof InputModalityModel.Type\n\nexport const InputModalityMessage = defineMessageUnion({ Changed: { modality: Modality } })\nexport type InputModalityMessage = typeof InputModalityMessage.Type\n\nconst MODIFIERS = new Set(['Shift', 'Control', 'Alt', 'Meta', 'CapsLock'])\n\n/** A modifier alone says nothing about how the page is being driven. */\nexport const modalityOfKey = (key: string): Modality | null =>\n  MODIFIERS.has(key) ? null : 'keyboard'\n\nconst modalityStream = (): Stream.Stream<InputModalityMessage> => {\n  if (typeof window === 'undefined') return Stream.empty\n  return Stream.mergeAll(\n    [\n      Stream.fromEventListener<KeyboardEvent>(window, 'keydown', { capture: true }).pipe(\n        Stream.filter(event => modalityOfKey(event.key) !== null),\n        Stream.map(() => InputModalityMessage.Changed({ modality: 'keyboard' })),\n      ),\n      Stream.fromEventListener(window, 'pointerdown', { capture: true }).pipe(\n        Stream.map(() => InputModalityMessage.Changed({ modality: 'pointer' })),\n      ),\n    ],\n    { concurrency: 'unbounded' },\n  )\n}\n\n/**\n * Input modality as a bundle: whether the user last drove the page by\n * keyboard or by pointer. The browser reports the facts; the Model keeps the\n * answer, so a view can show a focus ring only for keyboard users without\n * reading the DOM, and a replay sees the same answer. CSS `:focus-visible`\n * is the floor; this is for JavaScript that must know.\n */\nexport const InputModality = Bundle.make('InputModality', {\n  Model: InputModalityModel,\n  Message: InputModalityMessage,\n  init: () => ({ model: { modality: 'unknown' as const } }),\n  update: (model, message) =>\n    model.modality === message.modality ? { model } : { model: { modality: message.modality } },\n  subscriptions: (): Subscription.Subscriptions<InputModalityModel, InputModalityMessage> =>\n    Subscription.make<InputModalityModel, InputModalityMessage>()(() => ({\n      changes: Subscription.persistentEntry(modalityStream()),\n    })),\n})\n"],"mappings":";;;;;AAKA,MAAa,WAAW,OAAO,SAAS;CAAC;CAAY;CAAW;AAAS,CAAC;AAG1E,MAAa,qBAAqB,OAAO,OAAO,EAAE,UAAU,SAAS,CAAC;AAGtE,MAAa,uBAAuB,mBAAmB,EAAE,SAAS,EAAE,UAAU,SAAS,EAAE,CAAC;AAG1F,MAAM,4BAAY,IAAI,IAAI;CAAC;CAAS;CAAW;CAAO;CAAQ;AAAU,CAAC;;AAGzE,MAAa,iBAAiB,QAC5B,UAAU,IAAI,GAAG,IAAI,OAAO;AAE9B,MAAM,uBAA4D;CAChE,IAAI,OAAO,WAAW,aAAa,OAAO,OAAO;CACjD,OAAO,OAAO,SACZ,CACE,OAAO,kBAAiC,QAAQ,WAAW,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,KAC5E,OAAO,QAAO,UAAS,cAAc,MAAM,GAAG,MAAM,IAAI,GACxD,OAAO,UAAU,qBAAqB,QAAQ,EAAE,UAAU,WAAW,CAAC,CAAC,CACzE,GACA,OAAO,kBAAkB,QAAQ,eAAe,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,KACjE,OAAO,UAAU,qBAAqB,QAAQ,EAAE,UAAU,UAAU,CAAC,CAAC,CACxE,CACF,GACA,EAAE,aAAa,YAAY,CAC7B;AACF;;;;;;;;AASA,MAAa,gBAAgB,OAAO,KAAK,iBAAiB;CACxD,OAAO;CACP,SAAS;CACT,aAAa,EAAE,OAAO,EAAE,UAAU,UAAmB,EAAE;CACvD,SAAS,OAAO,YACd,MAAM,aAAa,QAAQ,WAAW,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,UAAU,QAAQ,SAAS,EAAE;CAC5F,qBACE,aAAa,KAA+C,CAAC,QAAQ,EACnE,SAAS,aAAa,gBAAgB,eAAe,CAAC,EACxD,EAAE;AACN,CAAC"}

package/dist/events/keyboard.d.ts

@@ -0,0 +1,30 @@
+import { Schema, Stream } from "effect";
+import { KeyPress } from "./hotkeys.js";
+export declare const KeyboardMessage: import("foldkit/message").MessageUnion<{
+  readonly Pressed: {
+    key: Schema.String;
+    repeat: Schema.Boolean;
+    ctrl: Schema.Boolean;
+    shift: Schema.Boolean;
+    alt: Schema.Boolean;
+    meta: Schema.Boolean;
+  };
+  readonly Released: {
+    key: Schema.String;
+  };
+}>;
+export type KeyboardMessage = typeof KeyboardMessage.Type;
+/**
+ * Key presses and releases on the window. Without a window the stream is
+ * empty instead of throwing. Lift with `Subscription.persistentEntry`, mapping
+ * into the parent's Message.
+ */
+export declare const keyboardEvents: (options?: {
+  /**
+   * Whether to cancel a press's default (the page scrolling under an arrow
+   * key, the browser's own shortcut), decided in the listener, since a
+   * default can only be cancelled before the event finishes dispatching.
+   */
+  readonly preventDefault?: (press: KeyPress) => boolean;
+}) => Stream.Stream<KeyboardMessage>;
+//# sourceMappingURL=keyboard.d.ts.map

package/dist/events/keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","names":[],"sources":["../../src/events/keyboard.ts"],"mappings":";;qBAUa,2CAAe;;IAExB,KAAG,OAAA;IACH,QAAM,OAAA;IACN,MAAI,OAAA;IACJ,OAAK,OAAA;IACL,KAAG,OAAA;IACH,MAAI,OAAA;;;IAEM,KAAG,OAAA;;;YAEL,yBAAyB,gBAAgB;;;;;;qBAOxC,iBAAc;;;;;;WAOd,kBAAkB,OAAO;MAEnC,OAAO,OAAO"}

package/dist/events/keyboard.js

@@ -0,0 +1,55 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/events/keyboard.ts
+/**
+* Keyboard as an entry — not a bundle, because the parent owns whatever key
+* state it keeps (a held-keys set, a shortcut map, a focused field): this
+* reports presses and releases, including auto-repeat, and the parent
+* stores what matters. Hotkey matching stays application policy.
+*/
+const KeyboardMessage = defineMessageUnion({
+	Pressed: {
+		key: Schema.String,
+		repeat: Schema.Boolean,
+		ctrl: Schema.Boolean,
+		shift: Schema.Boolean,
+		alt: Schema.Boolean,
+		meta: Schema.Boolean
+	},
+	Released: { key: Schema.String }
+});
+/**
+* Key presses and releases on the window. Without a window the stream is
+* empty instead of throwing. Lift with `Subscription.persistentEntry`, mapping
+* into the parent's Message.
+*/
+const keyboardEvents = (options = {}) => {
+	if (typeof window === "undefined") return Stream.empty;
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const down = (event) => {
+			const press = KeyboardMessage.Pressed({
+				key: event.key,
+				repeat: event.repeat,
+				ctrl: event.ctrlKey,
+				shift: event.shiftKey,
+				alt: event.altKey,
+				meta: event.metaKey
+			});
+			if (options.preventDefault?.(press) === true) event.preventDefault();
+			Queue.offerUnsafe(queue, press);
+		};
+		const up = (event) => Queue.offerUnsafe(queue, KeyboardMessage.Released({ key: event.key }));
+		window.addEventListener("keydown", down);
+		window.addEventListener("keyup", up);
+		return {
+			down,
+			up
+		};
+	}), ({ down, up }) => Effect.sync(() => {
+		window.removeEventListener("keydown", down);
+		window.removeEventListener("keyup", up);
+	})));
+};
+export { KeyboardMessage, keyboardEvents };
+
+//# sourceMappingURL=keyboard.js.map

package/dist/events/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","names":[],"sources":["../../src/events/keyboard.ts"],"sourcesContent":["/**\n * Keyboard as an entry — not a bundle, because the parent owns whatever key\n * state it keeps (a held-keys set, a shortcut map, a focused field): this\n * reports presses and releases, including auto-repeat, and the parent\n * stores what matters. Hotkey matching stays application policy.\n */\nimport { Effect, Queue, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type { KeyPress } from './hotkeys.js'\n\nexport const KeyboardMessage = defineMessageUnion({\n  Pressed: {\n    key: Schema.String,\n    repeat: Schema.Boolean,\n    ctrl: Schema.Boolean,\n    shift: Schema.Boolean,\n    alt: Schema.Boolean,\n    meta: Schema.Boolean,\n  },\n  Released: { key: Schema.String },\n})\nexport type KeyboardMessage = typeof KeyboardMessage.Type\n\n/**\n * Key presses and releases on the window. Without a window the stream is\n * empty instead of throwing. Lift with `Subscription.persistentEntry`, mapping\n * into the parent's Message.\n */\nexport const keyboardEvents = (\n  options: {\n    /**\n     * Whether to cancel a press's default (the page scrolling under an arrow\n     * key, the browser's own shortcut), decided in the listener, since a\n     * default can only be cancelled before the event finishes dispatching.\n     */\n    readonly preventDefault?: (press: KeyPress) => boolean\n  } = {},\n): Stream.Stream<KeyboardMessage> => {\n  if (typeof window === 'undefined') return Stream.empty\n  return Stream.callback<KeyboardMessage>(queue =>\n    Effect.acquireRelease(\n      Effect.sync(() => {\n        const down = (event: KeyboardEvent) => {\n          const press = KeyboardMessage.Pressed({\n            key: event.key,\n            repeat: event.repeat,\n            ctrl: event.ctrlKey,\n            shift: event.shiftKey,\n            alt: event.altKey,\n            meta: event.metaKey,\n          })\n          if (options.preventDefault?.(press) === true) event.preventDefault()\n          Queue.offerUnsafe(queue, press)\n        }\n        const up = (event: KeyboardEvent) =>\n          Queue.offerUnsafe(queue, KeyboardMessage.Released({ key: event.key }))\n        window.addEventListener('keydown', down)\n        window.addEventListener('keyup', up)\n        return { down, up }\n      }),\n      ({ down, up }) =>\n        Effect.sync(() => {\n          window.removeEventListener('keydown', down)\n          window.removeEventListener('keyup', up)\n        }),\n    ),\n  )\n}\n"],"mappings":";;;;;;;;;AAUA,MAAa,kBAAkB,mBAAmB;CAChD,SAAS;EACP,KAAK,OAAO;EACZ,QAAQ,OAAO;EACf,MAAM,OAAO;EACb,OAAO,OAAO;EACd,KAAK,OAAO;EACZ,MAAM,OAAO;CACf;CACA,UAAU,EAAE,KAAK,OAAO,OAAO;AACjC,CAAC;;;;;;AAQD,MAAa,kBACX,UAOI,CAAC,MAC8B;CACnC,IAAI,OAAO,WAAW,aAAa,OAAO,OAAO;CACjD,OAAO,OAAO,UAA0B,UACtC,OAAO,eACL,OAAO,WAAW;EAChB,MAAM,QAAQ,UAAyB;GACrC,MAAM,QAAQ,gBAAgB,QAAQ;IACpC,KAAK,MAAM;IACX,QAAQ,MAAM;IACd,MAAM,MAAM;IACZ,OAAO,MAAM;IACb,KAAK,MAAM;IACX,MAAM,MAAM;GACd,CAAC;GACD,IAAI,QAAQ,iBAAiB,KAAK,MAAM,MAAM,MAAM,eAAe;GACnE,MAAM,YAAY,OAAO,KAAK;EAChC;EACA,MAAM,MAAM,UACV,MAAM,YAAY,OAAO,gBAAgB,SAAS,EAAE,KAAK,MAAM,IAAI,CAAC,CAAC;EACvE,OAAO,iBAAiB,WAAW,IAAI;EACvC,OAAO,iBAAiB,SAAS,EAAE;EACnC,OAAO;GAAE;GAAM;EAAG;CACpB,CAAC,IACA,EAAE,MAAM,SACP,OAAO,WAAW;EAChB,OAAO,oBAAoB,WAAW,IAAI;EAC1C,OAAO,oBAAoB,SAAS,EAAE;CACxC,CAAC,CACL,CACF;AACF"}

package/dist/events/pointer.d.ts

@@ -0,0 +1,15 @@
+import { Schema, Stream } from "effect";
+export declare const PointerMessage: import("foldkit/message").MessageUnion<{
+  readonly Moved: {
+    x: Schema.Number;
+    y: Schema.Number;
+  };
+}>;
+export type PointerMessage = typeof PointerMessage.Type;
+/**
+ * Pointer moves on the window. Without a window the stream is empty instead
+ * of throwing. Lift with `Subscription.persistentEntry`, mapping into the
+ * parent's Message.
+ */
+export declare const pointerEvents: () => Stream.Stream<PointerMessage>;
+//# sourceMappingURL=pointer.d.ts.map

package/dist/events/pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer.d.ts","names":[],"sources":["../../src/events/pointer.ts"],"mappings":";qBASa,0CAAc;;IAChB,GAAC,OAAA;IAAiB,GAAC,OAAA;;;YAElB,wBAAwB,eAAe;;;;;;qBAOtC,qBAAoB,OAAO,OAAO"}