foldkit-primitives 0.3.0 → 0.4.0

package/README.md

@@ -50,6 +50,12 @@ A bundle holds no state and performs no I/O by itself. The parent Model owns
 the placed slice; the browser (or server, or clock) only reports facts as
 Messages. The same rule as everywhere else: observation is not ownership.
 
+A Message that changes nothing (a repeated resize, `Started` while running,
+a total that is already held) returns the Model it was given, and a
+placement then returns the parent unchanged. Foldkit renders only when the
+root Model changes identity, so such a Message renders nothing, and a
+`createLazy` view over a placed slice is skipped while the slice is the same.
+
 Solid developers will notice missing plumbing: there is no event bus
 because Messages are the bus, no memo because derivations are pure reads
 over the Model, and no reactive map or store because the Model holds plain
@@ -91,11 +97,11 @@ Each subpath is one concern, one import:
 - `time` — clock facts: Timer, Interval, Debounce, Throttle, relative time
 - `state` — owned UI state: Pagination, History, Locale, SelectionSet, Virtual, range
 - `motion` — animation state: Tween, Spring, Presence
-- `interaction` — a Bundle (or Mount) and its `foldkit-mixins` Behavior: RovingTabindex, Typeahead, ListNavigation, GridNavigation, FocusScope, Press, LongPress, Move, FocusVisible, DismissLayer, ScrollLock, HideOutside, Selection, LiveAnnounce
+- `interaction` — a Bundle (or Mount) and its `foldkit-mixins` Behavior: RovingTabindex, Typeahead, ListNavigation, GridNavigation, TreeNavigation, FocusScope, Press, LongPress, Move, Targets, PointerDrag, EditableText, FocusVisible, DismissLayer, ScrollLock, HideOutside, Selection, LiveAnnounce
 - `device` — hardware: Geolocation, MediaDevices, MediaStream, Permissions, Fullscreen
 - `events` — raw browser events: Visibility, WindowSize, Idle, InputModality, keyboard, pointer, scroll, focus
 - `observers` — element Mounts: Resize, Intersection, Mutation, Bounds
-- `dom` — element Mounts and one-shot Commands: Autofocus, FocusScope, Move, ScrollLock, HideOutside, InputMask, clipboard, share, script loading
+- `dom` — element Mounts and one-shot Commands: Autofocus, FocusScope, KeepInView, Measure, Move, Targets, PointerDrag, EditableText, ScrollLock, HideOutside, InputMask, clipboard, share, script loading
 
 ## Sixty seconds: follow the color scheme
 
@@ -207,8 +213,12 @@ SSE spec.
 holds `{ url, status, lastError }` with `status` moving
 closed → connecting → open. The resource owns the socket (one assembly holds
 one); `send` is a placed helper whose command writes through the resource tag
-and yields `Sent` on dispatch, `SendFailed` when no connection is open — a
-closed socket's `send` is a silent no-op per spec, so the bundle checks first.
+and yields `Sent { data }` on dispatch, carrying what was sent, and
+`SendFailed` when no connection is open — a closed socket's `send` is a
+silent no-op per spec, so the bundle checks first. Args `{ url,
+connectTimeoutMs? }`: with a timeout, a socket still connecting when it runs
+out is closed and reported as `TimedOut` (status closed, `lastError` set);
+without one, an attempt waits as long as the browser does.
 Incoming `Received` notifies without storing: project the payload into your
 own field to keep it. `createSocket` defaults to the platform WebSocket, read
 lazily so tests substitute a double; the socket service rides the assembly
@@ -230,14 +240,41 @@ the Command fails, instead of throwing.
 `Started`/`Stopped`/`Ticked`, args `{ intervalMs }` (positive and finite —
 anything else is rejected at placement). The tick stream runs on
 Effect's clock, so tests advance it with TestClock instead of waiting; while
-stopped the stream is empty. Restarting keeps the count; only `Ticked`
-advances it.
+stopped the stream is empty. The first tick comes one interval after
+`Started`. Restarting keeps the count; only `Ticked` advances it.
 
 `Interval` is the wall-clock sibling: Model `{ running, lastAt }`,
 `Ticked { at }` stamped from Effect's clock. `Timer` counts ticks,
 `Interval` records when — views render clocks and elapsed times from
 `lastAt`. Same args, same TestClock story, same silence while stopped.
 
+Both own their `running` flag, at an interval fixed where they are placed.
+When the parent's Model already decides whether the clock runs and how fast
+(a game's phase and its score), a second flag would be a second owner of that
+fact. `ticks` is the entry for that case: `intervalMs` reads the interval from
+the Model, `None` while stopped, and `onTick` makes the parent's Message with
+the tick's time:
+
+```ts
+import { Option } from 'effect'
+import * as Subscription from 'foldkit/subscription'
+import { ticks } from 'foldkit-primitives/time'
+
+const subscriptions = Subscription.make<Game, GameMessage>()(() => ({
+  clock: ticks({
+    intervalMs: (game: Game) =>
+      game.playing ? Option.some(Math.max(80, 150 - game.points)) : Option.none(),
+    onTick: () => GameMessage.TickedClock(),
+  }),
+}))
+```
+
+A Model change that leaves the interval alone does nothing. A new interval
+applies from the next tick, without restarting the clock, so a game that
+speeds up keeps its rhythm instead of ticking at once; `None` stops it, and
+`Some` again starts afresh, one interval before the first tick. `Timer` and
+`Interval` are built on it.
+
 `debounce({ name, value })` is a factory over any value Schema (like
 `history`): `Changed` restarts a `{ delayMs }` timer, and only the latest
 value settles — as an OutMessage the placement must handle with `onOut`, so
@@ -285,9 +322,11 @@ focus `{ tag, id }` — elements cross as tag and id, never as live nodes.
 `matchHotkey("ctrl+shift+k", press)` answers whether a press is a shortcut,
 so `update` stays a table of chords; matching is exact and auto-repeat never
 matches. When the observed target itself depends on state, scope the entry
-through subscription dependencies and it restreams on change. When the
-handler must cancel the browser default, core
-`Subscription.fromEventFilterMap` maps synchronously inside dispatch. Lift
+through subscription dependencies and it restreams on change.
+`keyboardEvents({ preventDefault: press => ... })` cancels the default of the
+presses the predicate picks (the arrows scrolling a game's page,
+`matchHotkey('ctrl+s', press)`), decided in the listener, because a default
+can only be cancelled while the event is dispatching. Lift
 with `Subscription.persistent`, mapping into the parent's Message; without
 a window each stream is empty instead of throwing.
 
@@ -357,7 +396,10 @@ owns fullscreen state.
 `copyText` copies text as a Command: use it in `update` beside any bundle.
 It yields `Copied` on success and `CopyFailed` otherwise — denial, insecure
 context, or no clipboard API (SSR) all become the failure Message instead of
-throwing. No Model involved: the clipboard is not application state.
+throwing. `readText()` reads it the same way, yielding a
+`ClipboardReadMessage`: `Read { text }`, or `ReadFailed` when the browser
+refuses. No Model involved: the clipboard is not
+application state.
 
 `share(data)` posts `{ title?, text?, url? }` to the platform sheet: `Shared`
 on success, `Dismissed` on sheet cancel (its own outcome, not a failure),
@@ -373,6 +415,26 @@ rewrites the field with approximate caret restore, and emits
 `Input { value, raw }` with masked and unmasked text. The parent owns the
 state, like any controlled input.
 
+`KeepInView({ selector })` keeps what is marked in view: whenever an element in
+its subtree newly matches `selector` (the row just selected, the node just
+inserted), it is scrolled into view the least amount that shows it. It sends no
+Message and redraws nothing, so a focused row stays focused. Where there is no
+layout (jsdom), it scrolls nothing.
+
+`Measure({ targets: { selected: '[aria-selected="true"]' } })` measures, for
+each named target, the first element in its subtree that matches, relative to
+its scroll box, and writes `--fk-selected-x`, `-y`, `-w`, `-h` (pixels) and
+`--fk-selected-display` (`block`, or `none` while nothing matches) on the
+element (`measured('selected')` names them). A child placed absolutely from
+them, such as an editor's selection outline, sits over the target and scrolls
+with it. Where an element is, is presentation: it sends no Message and keeps
+nothing in the Model. It measures again when the subtree changes, as the
+records arrive, so the box moves in the frame the change is drawn in; and, at
+most once a frame, when the element scrolls, when it or a target changes size,
+when the window resizes, when an image or a font inside loads, and on each
+frame of a transition or an animation inside. Anything else that moves a
+target without resizing it (a stylesheet added) is seen at the next of these.
+
 ## State: `foldkit-primitives/state`
 
 > Reference: [`./state/README.md`](./state/README.md)
@@ -387,9 +449,18 @@ item's index for a slice or a query. Loading data stays the application's job:
 this bundle owns the page, not the items.
 
 `history({ name, value, capacity })` makes an undo/redo bundle over any value
-Schema. The Model holds `{ past, present, future }`; `Push` records and drops
-the redo future, `Undo`/`Redo` move one step, `Clear` empties both sides while
-keeping the present. The past holds at most `capacity` entries (default 100);
+Schema. The Model holds `{ past, present, future, group }`; `Push` records and
+drops the redo future (an empty future is kept as it was, so a view reading it
+is not drawn again per push), `Undo`/`Redo` move one step, `GoTo { step }`
+jumps to any kept value, counted from the oldest (0) so the present is at
+`past.length`, and `Clear` empties both sides while keeping the present. A `Push` may name a `group`: consecutive pushes of
+the same group are one step, so typing a word undoes as a whole, with no clock.
+The steps are also pure functions, `History.start`, `push`, `undo`, `redo`,
+`goTo` and `clear`, for a parent that records an edit in the same transition that makes it
+(the page Builder keeps its page this way). Two more are only functions:
+`History.close(model)` ends the group, so the same group pushed again is a step
+of its own, and `History.revert(model, group)` takes back the step `group` is
+making with nothing left to redo, which is what a cancelled edit leaves. The past holds at most `capacity` entries (default 100);
 a negative or fractional capacity throws at the factory, naming it. The
 factory attaches the Message union, so placements dispatch
 `EditHistory.Message.Push(...)`. `canUndo`/`canRedo` read the edges:
@@ -425,6 +496,11 @@ the spacer height, `isAtEnd(model, keys, viewportHeight, threshold)` is the
 infinite-scroll check (an empty list counts as ended), `distanceToEnd`
 answers the pixels remaining for prefetch thresholds, and `offsetFor`
 computes programmatic scroll targets the application actuates itself.
+These share one table of row offsets, built once per `keys` array and
+`heights` record and then searched, so keep the keys array between renders
+(derive it where the list changes, not in the view) and a scroll costs
+O(log n) instead of a pass over every row. Both are compared by identity:
+never change a keys array in place.
 `Prune` drops heights for departed keys — the bundle never sees key order.
 Poisoned positions and heights are ignored, never stored. For window-
 scrolled lists, map the scroll entry into `Scrolled`; for follow-bottom,
@@ -616,6 +692,39 @@ const Keys = GridNavigation.behavior(Cells, args)(CalendarSlots)<Model, Message>
 })
 ```
 
+`TreeNavigation` is the tree counterpart, after the WAI-ARIA tree pattern,
+for a file explorer, a page's layers, or a nested menu: Up and Down through
+the rows that are showing, Right opens a row or steps into it, Left closes it or
+steps out to its parent, Home and End go to the first and last row. The view
+gives every row, open or not, in tree order, each with its `parent` and whether
+it is a `branch`; `TreeNavigation.shown(rows, model, args)` is the rows that are
+showing, with their level and place among their siblings. The Model slice is
+`{ current, toggled }`: openness is stored as the rows toggled away from
+`openByDefault`, so a layers panel that starts open and a file tree that starts
+closed are one bundle with a different arg. The Behavior writes each showing
+row's `id` (through `domId`, by default the row's own), `role="treeitem"`,
+`aria-level`, `aria-posinset`, `aria-setsize`, `aria-expanded` on a branch,
+`aria-disabled`, a roving `tabindex` and `OnFocus`; the container's keys move
+focus by id, or open and close the current row in place. Focus in the tree
+follows its stop when a transition it did not see moves it or removes the
+focused row (the `FollowTabStop` Mount, in `foldkit-primitives/dom`, which
+never takes focus from outside the container). The level is also the
+custom property `--fk-tree-level`, 1 at the top, so one rule indents any depth:
+`padding-inline-start: calc(var(--fk-tree-level) * 1rem)`.
+
+```ts
+const Layers = Bundle.declare(TreeNavigation.bundle, 'layers')
+// place with { args: { openByDefault: true } }
+const Keys = TreeNavigation.behavior(Layers, { openByDefault: true })(TreeSlots)<Model, Message>({
+  container: 'tree',
+  item: 'row',
+  rows: model => model.folders.map(folder => ({ id: folder.id, parent: folder.parent, branch: folder.hasChildren })),
+})
+```
+
+The pure `move(shown, current, key, modifiers, model, args, direction?)` answers
+with `Focus`, `Open` or `Close`, for a view that wires its own.
+
 `FocusScope` is the one entry here that is a Mount, not a Bundle: which
 element has focus is a DOM fact, so nothing crosses to the Model. The Mount
 lives in `foldkit-primitives/dom`; `FocusScope.behavior(Slots)<Input,
@@ -680,6 +789,86 @@ and a secondary button are ignored; capture is released with the Mount.
 `Draggable` slot and maps each fact into the view's Messages; a drag's meaning
 (a threshold, a snap, a reorder) is the parent's `update`.
 
+`Targets` is which marked descendant of a container the pointer is over, and
+which one was pressed, as one Mount on the container rather than one per item.
+A descendant is marked by an attribute holding its id (a canvas's
+`data-composition-node`, a table's `data-row`), and the nearest marked ancestor
+of the event's target, inside the container, is the one reported:
+`TargetHovered { id }` once per change, `null` when there is none or the
+pointer leaves, and `TargetPressed { id, shiftKey, altKey, ctrlKey, metaKey }`
+on a click. `preventDefault: true` stops a press's default, such as a link
+navigating inside an editor's canvas. The Mount is `Targets({ attribute,
+preventDefault })` in `foldkit-primitives/dom`; `Targets.behavior(Slots)<Input,
+Message>({ container, attribute, preventDefault?, toMessage })` attaches it.
+`targetOf(container, from, attribute)` is the pure lookup.
+
+`EditableText` is text typed into a marked descendant of a container while it
+is `contenteditable`, as one Mount on the container. The view decides which
+field is editable; the Mount focuses it as it becomes so (made editable, or
+drawn editable), with the caret at its end, and at no other time: a field
+editable all along, or another going away, moves no focus. It reads what is
+typed:
+
+- **Text, never markup.** It reads `innerText`. A field is one line unless it
+  carries `aria-multiline="true"`, and in one line a line break becomes a
+  space. Where the browser lacks `contenteditable="plaintext-only"`, a paste is
+  inserted as its text.
+- **`TextEdited { field, text }`** on each change, `field` being the marking
+  attribute's value. Nothing is reported while an input method composes; the
+  composed text arrives once.
+- **`TextCommitted { field, text }`** on Enter (Shift+Enter breaks a line in a
+  multiline field) or on leaving the field; **`TextCancelled { field, initial }`**
+  on Escape, which also puts the text the field had when the edit began (on
+  focus, or on the first keystroke after an edit ended) back in the DOM, the
+  caret at its end. A view that stopped redrawing the field while it was edited
+  would not. An edit ends once: the blur after Enter commits nothing more.
+- **Focus comes back to the container** when Enter or Escape ended an edit and
+  the view then removes the field or makes it no longer editable, which leaves
+  focus on nothing; give the container a `tabindex`, and the next key (an
+  undo) reaches it. A field left by the author keeps no such claim.
+- **`EditAsked { field }`** on a double-click over a marked field that is not
+  editable yet: the view's cue to make it so.
+
+The Mount is `EditableText({ attribute })` in `foldkit-primitives/dom`;
+`EditableText.behavior(Slots)<Input, Message>({ container, attribute, toMessage })`
+attaches it. What a change means (a prop set, an undo group) is the parent's
+`update`.
+
+`PointerDrag` is dragging one marked descendant onto another, marked the way
+`Targets` marks them. A primary press on one that moves more than
+`DRAG_THRESHOLD` (4px) starts a drag (`DragStarted { id }`); then, once per
+change, `DraggedOver { over }` says which other marked descendant the pointer
+is over and in which third of its box, `{ id, zone: 'before' | 'inside' |
+'after' }`, or `null`. Releasing is `DragDropped { id, over }`, and Escape, a
+cancelled pointer, or a button found released mid-drag is `DragCancelled { id }`.
+An Escape that cancels is heard on the way down and goes no further, so the
+focused element's own Escape (a canvas's deselect) does not also run.
+It follows the pointer that pressed and ignores a second one; the element under
+it is found by position, so a touch or a pen, which the browser captures to
+where it went down, drags too, once the marked elements have `touch-action:
+none` so a finger drags rather than scrolls. The click a drop ends with is
+swallowed, so a `Targets` on the same container does not also press. A press
+in `contenteditable` text selects text and starts no drag. It writes
+no roles, `tabindex` or keys, so it sits beside a tree's or a listbox's own;
+the keyboard's way to do what a drag does is yours to give. Boxes are measured
+as the pointer moves and never kept; an element drawn as `display: contents`
+is measured by its first child (`boxOf`). The Mount is
+`PointerDrag({ attribute })` in `foldkit-primitives/dom`;
+`PointerDrag.behavior(Slots)<Input, Message>({ container, attribute, toMessage })`
+attaches it, and `zoneOf(box, y)` is the pure split.
+
+A drag may also land somewhere other than among its own: with
+`targets: { attribute: 'data-composition-node', within: '#page' }`, what is
+dragged is still one of the container's marked descendants (a palette's
+tiles), and `over` is an element marked by that attribute inside the one
+`within` selects (the page's nodes). Its own tiles, and a matching element
+outside that one, are then over nothing. `within` is looked for nearest
+first, under the container's closest ancestor that holds a match, so two
+editors on one page each drop onto their own page. Such a drag's
+`DraggedOver` and `DragDropped` also carry `region`: whether the pointer is
+inside that element, so `over: null` with `region: true` is its empty space
+(an empty page, the space below its last node), and with `false`, elsewhere.
+
 `FocusVisible` is the one entry whose Bundle lives elsewhere: `InputModality`
 in `foldkit-primitives/events` keeps `{ modality }` (`'keyboard'`, `'pointer'`,
 or `'unknown'` before any input), fed by the window's `keydown` (a modifier

package/dist/device/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/device/fullscreen.ts","../../src/device/geolocation.ts","../../src/device/media-devices.ts","../../src/device/media-stream.ts","../../src/device/permissions.ts"],"mappings":";;;;;qBAWa,6CAAiB;;;;;;;;;;YAMlB,2BAA2B,kBAAkB;;;;;;;qBAW5C,kBAAmB,SAAS,YAAU,QAAQ;;qBA0B9C,sBAAqB,QAAQ;;;;;qBAgC7B,yBAAwB,OAAO,OAAO;;;qBC1EtC,aAAW,OAAA;;;;;YAKZ,qBAAqB,YAAY;qBAEhC,kBAAgB,OAAA;;;;;;;;;YAKjB,0BAA0B,iBAAiB;qBAE1C,8CAAkB;;;;;;;;;;;YASnB,4BAA4B,mBAAmB;qBAmD9C,aAAW,OAAA;;;;;;;;;;;;;;;;;;;;;qBCxEX,aAAW,OAAA;;;;;;YAMZ,qBAAqB,YAAY;qBAEhC,mBAAiB,OAAA;;;;;;;;;;YAKlB,2BAA2B,kBAAkB;qBAE5C,+CAAmB;;;;;;;;;;;;;;;;YAOpB,6BAA6B,oBAAoB;;iBAG5C;EACf,oBAAoB,QAClB;aACW;aACA;aACA;aACA;;EAGb,iBAAiB,cAAc;EAC/B,oBAAoB,cAAc;;qBAUvB,qBAAsB,qBAAqB;WAC7C,MAAM;;WAEN,WAAW,WAAW,cAAc;MAC9C,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBChDY,kBAAgB,OAAA;;;;YAIjB,0BAA0B,iBAAiB;qBAE1C,8CAAkB;;;;;;;sBAAlB,OAAA;;;YAQD,4BAA4B,mBAAmB;;iBAG1C;EACf;;;iBAIe;EACf,aAAa,cAAc;;iBAGZ;WACN;WACA;;;qBAIE,YAAU,gBAAA,gBAAA,mBAAA,gBAAA;;YAGX,oBAAoB,gBAAgB,iBAAiB;qBAoBpD,oBAAqB,qBAAqB;WAC5C,MAAM;;WAEN,YACL,aAAa,2BAA2B,QAAQ;MACrD,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBC5DY,iBAAe,OAAA;YAChB,yBAAyB,gBAAgB;qBAExC,kBAAgB,OAAA;;;;YAIjB,0BAA0B,iBAAiB;qBAE1C,8CAAkB;;;;;;;;;;;;;YAMnB,4BAA4B,mBAAmB;;iBAG1C;WACN;EACT;;;iBAIe;EACf,MAAM;aAAuB;MAAiB,QAAQ;;UAG9C;WACC,UAAU,oBAAoB;WAC9B,UAAU,SAAS,eAAe;WAClC,QAAQ,MAAM,MAAM;;;qBAIlB,OAAK,gBAAA,gBAAA,UAAA,gBAAA;;YAGN,eAAe,gBAAgB,iBAAiB;qBAuB/C,oBAAqB,qBAAqB;WAC5C,MAAM;;WAEN,WAAW,WAAW,cAAc;MAC9C,OAAA,OAAA;WAYqB,OAAA;;;;;;;;;;;;;;;;;;;;;EApCb,OAAA,gBAAgB,MACrB,kBACA,oBACA,OAAO,OAAO,wBACd,UACA,eACC,UAAU,aAAa"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/device/fullscreen.ts","../../src/device/geolocation.ts","../../src/device/media-devices.ts","../../src/device/media-stream.ts","../../src/device/permissions.ts"],"mappings":";;;;;qBAWa,6CAAiB;;;;;;;;;;YAMlB,2BAA2B,kBAAkB;;;;;;;qBAW5C,kBAAmB,SAAS,YAAU,QAAQ;;qBA0B9C,sBAAqB,QAAQ;;;;;qBAgC7B,yBAAwB,OAAO,OAAO;;;qBCzEtC,aAAW,OAAA;;;;;YAKZ,qBAAqB,YAAY;qBAEhC,kBAAgB,OAAA;;;;;;;;;YAKjB,0BAA0B,iBAAiB;qBAE1C,8CAAkB;;;;;;;;;;;YASnB,4BAA4B,mBAAmB;qBAmD9C,aAAW,OAAA;;;;;;;;;;;;;;;;;;;;;qBCxEX,aAAW,OAAA;;;;;;YAMZ,qBAAqB,YAAY;qBAEhC,mBAAiB,OAAA;;;;;;;;;;YAKlB,2BAA2B,kBAAkB;qBAE5C,+CAAmB;;;;;;;;;;;;;;;;YAOpB,6BAA6B,oBAAoB;;iBAa5C;EACf,oBAAoB,QAClB;aACW;aACA;aACA;aACA;;EAGb,iBAAiB,cAAc;EAC/B,oBAAoB,cAAc;;qBAUvB,qBAAsB,qBAAqB;WAC7C,MAAM;;WAEN,WAAW,WAAW,cAAc;MAC9C,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBC1DY,kBAAgB,OAAA;;;;YAIjB,0BAA0B,iBAAiB;qBAE1C,8CAAkB;;;;;;;sBAAlB,OAAA;;;YAQD,4BAA4B,mBAAmB;;iBAG1C;EACf;;;iBAIe;EACf,aAAa,cAAc;;iBAGZ;WACN;WACA;;;qBAIE,YAAU,gBAAA,gBAAA,mBAAA,gBAAA;;YAGX,oBAAoB,gBAAgB,iBAAiB;qBAoBpD,oBAAqB,qBAAqB;WAC5C,MAAM;;WAEN,YACL,aAAa,2BAA2B,QAAQ;MACrD,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBC5DY,iBAAe,OAAA;YAChB,yBAAyB,gBAAgB;qBAExC,kBAAgB,OAAA;;;;YAIjB,0BAA0B,iBAAiB;qBAE1C,8CAAkB;;;;;;;;;;;;;YAMnB,4BAA4B,mBAAmB;;iBAG1C;WACN;EACT;;;iBAIe;EACf,MAAM;aAAuB;MAAiB,QAAQ;;UAG9C;WACC,UAAU,oBAAoB;WAC9B,UAAU,SAAS,eAAe;WAClC,QAAQ,MAAM,MAAM;;;qBAIlB,OAAK,gBAAA,gBAAA,UAAA,gBAAA;;YAGN,eAAe,gBAAgB,iBAAiB;qBAuB/C,oBAAqB,qBAAqB;WAC5C,MAAM;;WAEN,WAAW,WAAW,cAAc;MAC9C,OAAA,OAAA;WAYqB,OAAA;;;;;;;;;;;;;;;;;;;;;EApCb,OAAA,gBAAgB,MACrB,kBACA,oBACA,OAAO,OAAO,wBACd,UACA,eACC,UAAU,aAAa"}

package/dist/device/index.mjs

@@ -1,3 +1,4 @@
+import { i as unlessSame } from "../internal-DP-xLKbT.mjs";
 import { Effect, Option, Queue, Schema, Stream } from "effect";
 import { defineMessageUnion } from "foldkit/message";
 import * as Subscription from "foldkit/subscription";
@@ -127,7 +128,7 @@ const Geolocation = Bundle.make("Geolocation", {
 		lastError: null
 	} }),
 	update: (model, message) => GeolocationMessage.match(message, {
-		Located: ({ latitude, longitude, accuracy }) => ({ model: {
+		Located: ({ latitude, longitude, accuracy }) => model.status === "ready" && model.coords !== null && model.coords.latitude === latitude && model.coords.longitude === longitude && model.coords.accuracy === accuracy ? { model } : { model: {
 			...model,
 			status: "ready",
 			coords: {
@@ -135,15 +136,15 @@ const Geolocation = Bundle.make("Geolocation", {
 				longitude,
 				accuracy
 			}
-		} }),
-		Denied: () => ({ model: {
+		} },
+		Denied: () => ({ model: unlessSame(model, {
 			...model,
 			status: "denied"
-		} }),
-		Failed: ({ message }) => ({ model: {
+		}) }),
+		Failed: ({ message }) => ({ model: unlessSame(model, {
 			...model,
 			lastError: message
-		} })
+		}) })
 	}),
 	subscriptions: () => Subscription.make()(() => ({ watch: Subscription.persistent(watchStream()) }))
 });
@@ -183,6 +184,7 @@ const MediaDevicesMessage = defineMessageUnion({
 	Denied: {},
 	Failed: { message: Schema.String }
 });
+const sameDevices = (a, b) => a.length === b.length && a.every((device, index) => device.deviceId === b[index].deviceId && device.groupId === b[index].groupId && device.kind === b[index].kind && device.label === b[index].label);
 const failMessage$2 = (error) => error instanceof Error ? error.message : String(error);
 const isDenied$1 = (error) => typeof error?.name === "string" && ["NotAllowedError", "SecurityError"].includes(error.name);
 const mediaDevices = (config) => {
@@ -239,19 +241,19 @@ const mediaDevices = (config) => {
 				model,
 				commands: [scan()]
 			}),
-			Refreshed: ({ devices }) => ({ model: {
+			Refreshed: ({ devices }) => model.status === "ready" && sameDevices(model.devices, devices) ? { model } : { model: {
 				...model,
 				status: "ready",
-				devices: [...devices]
-			} }),
-			Denied: () => ({ model: {
+				devices
+			} },
+			Denied: () => ({ model: unlessSame(model, {
 				...model,
 				status: "denied"
-			} }),
-			Failed: ({ message }) => ({ model: {
+			}) }),
+			Failed: ({ message }) => ({ model: unlessSame(model, {
 				...model,
 				lastError: message
-			} })
+			}) })
 		}),
 		subscriptions: () => Subscription.make()(() => ({ changes: Subscription.persistent(changedStream()) }))
 	});
@@ -306,32 +308,32 @@ const mediaStream = (config) => {
 			lastError: null
 		} }),
 		update: (model, message) => MediaStreamMessage.match(message, {
-			Started: () => ({ model: {
+			Started: () => model.status === "requesting" || model.status === "live" ? { model } : { model: {
 				...model,
 				status: "requesting"
-			} }),
-			Stopped: () => ({ model: {
+			} },
+			Stopped: () => ({ model: unlessSame(model, {
 				...model,
 				status: "idle"
-			} }),
-			Live: () => ({ model: {
+			}) }),
+			Live: () => ({ model: unlessSame(model, {
 				...model,
 				status: "live",
 				lastError: null
-			} }),
-			Ended: () => ({ model: {
+			}) }),
+			Ended: () => ({ model: unlessSame(model, {
 				...model,
 				status: "idle"
-			} }),
-			Denied: () => ({ model: {
+			}) }),
+			Denied: () => ({ model: unlessSame(model, {
 				...model,
 				status: "denied"
-			} }),
-			Failed: ({ message }) => ({ model: {
+			}) }),
+			Failed: ({ message }) => ({ model: unlessSame(model, {
 				...model,
 				status: "idle",
 				lastError: message
-			} })
+			}) })
 		}),
 		resources: (args) => ManagedResource.make()((entry) => ({ stream: entry(Schema.Option(Schema.Struct({
 			audio: Schema.Boolean,
@@ -405,79 +407,85 @@ const permissions = (config) => {
 			lastError: null
 		} }),
 		update: (model, message) => PermissionsMessage.match(message, {
-			Snapshot: ({ states }) => ({ model: {
-				...model,
-				states: { ...states }
-			} }),
-			Changed: ({ name, state }) => ({ model: {
+			Snapshot: ({ states }) => {
+				const next = unlessSame(model.states, { ...states });
+				return next === model.states ? { model } : { model: {
+					...model,
+					states: next
+				} };
+			},
+			Changed: ({ name, state }) => Object.hasOwn(model.states, name) && model.states[name] === state ? { model } : { model: {
 				...model,
 				states: {
 					...model.states,
 					[name]: state
 				}
-			} }),
-			Cleared: () => ({ model: {
+			} },
+			Cleared: () => Object.keys(model.states).length === 0 ? { model } : { model: {
 				...model,
 				states: {}
-			} }),
-			Failed: ({ message }) => ({ model: {
+			} },
+			Failed: ({ message }) => ({ model: unlessSame(model, {
 				...model,
 				lastError: message
-			} })
+			}) })
 		}),
-		resources: (args) => ManagedResource.make()((entry) => ({ watch: entry(Schema.Option(Schema.Array(Schema.String)), {
-			resource: Watch,
-			modelToMaybeRequirements: () => Option.some([...new Set(args.names)]),
-			acquire: (names) => Effect.gen(function* () {
-				const api = handle();
-				if (api === null) throw new Error("permissions are unavailable");
-				const events = yield* Queue.unbounded();
-				const statuses = /* @__PURE__ */ new Map();
-				let tail = Promise.resolve();
-				const offer = (message) => {
-					const run = () => Effect.runPromise(Queue.offer(events, message)).then(() => void 0, () => void 0);
-					tail = tail.then(run, run);
-				};
-				const queried = [];
-				for (const name of names) {
-					const status = yield* Effect.tryPromise({
-						try: () => api.query({ name }),
-						catch: (error) => error
-					});
-					queried.push([
-						name,
-						status,
-						readState(status.state, name)
-					]);
-				}
-				const snapshot = {};
-				for (const [name, status, state] of queried) {
-					status.onchange = () => {
-						try {
-							offer(PermissionsMessage.Changed({
-								name,
-								state: readState(status.state, name)
-							}));
-						} catch {
-							offer(PermissionsMessage.Failed({ message: `unknown permission state for ${name}` }));
-						}
+		resources: (args) => {
+			const names = Option.some([...new Set(args.names)]);
+			return ManagedResource.make()((entry) => ({ watch: entry(Schema.Option(Schema.Array(Schema.String)), {
+				resource: Watch,
+				modelToMaybeRequirements: () => names,
+				acquire: (names) => Effect.gen(function* () {
+					const api = handle();
+					if (api === null) throw new Error("permissions are unavailable");
+					const events = yield* Queue.unbounded();
+					const statuses = /* @__PURE__ */ new Map();
+					let tail = Promise.resolve();
+					const offer = (message) => {
+						const run = () => Effect.runPromise(Queue.offer(events, message)).then(() => void 0, () => void 0);
+						tail = tail.then(run, run);
 					};
-					statuses.set(name, status);
-					snapshot[name] = state;
-				}
-				return {
-					statuses,
-					snapshot,
-					events
-				};
-			}),
-			onAcquired: ({ snapshot }) => PermissionsMessage.Snapshot({ states: { ...snapshot } }),
-			onReleased: () => PermissionsMessage.Cleared(),
-			onAcquireError: (error) => PermissionsMessage.Failed({ message: failMessage(error) }),
-			release: ({ statuses, events }) => Effect.asVoid(Effect.andThen(Effect.sync(() => {
-				for (const status of statuses.values()) status.onchange = null;
-			}), Queue.shutdown(events)))
-		}) })),
+					const queried = [];
+					for (const name of names) {
+						const status = yield* Effect.tryPromise({
+							try: () => api.query({ name }),
+							catch: (error) => error
+						});
+						queried.push([
+							name,
+							status,
+							readState(status.state, name)
+						]);
+					}
+					const snapshot = {};
+					for (const [name, status, state] of queried) {
+						status.onchange = () => {
+							try {
+								offer(PermissionsMessage.Changed({
+									name,
+									state: readState(status.state, name)
+								}));
+							} catch {
+								offer(PermissionsMessage.Failed({ message: `unknown permission state for ${name}` }));
+							}
+						};
+						statuses.set(name, status);
+						snapshot[name] = state;
+					}
+					return {
+						statuses,
+						snapshot,
+						events
+					};
+				}),
+				onAcquired: ({ snapshot }) => PermissionsMessage.Snapshot({ states: { ...snapshot } }),
+				onReleased: () => PermissionsMessage.Cleared(),
+				onAcquireError: (error) => PermissionsMessage.Failed({ message: failMessage(error) }),
+				release: ({ statuses, events }) => Effect.asVoid(Effect.andThen(Effect.sync(() => {
+					for (const status of statuses.values()) status.onchange = null;
+				}), Queue.shutdown(events)))
+			}) }));
+		},
 		subscriptions: () => Subscription.make()(() => ({ changes: Subscription.persistent(Stream.unwrap(Effect.matchEffect(Watch.get, {
 			onFailure: () => Effect.succeed(Stream.empty),
 			onSuccess: ({ events }) => Effect.succeed(Stream.fromQueue(events))