foldkit-primitives 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # `foldkit-primitives`
 
-Ready-made [`foldkit-bundle`](./bundle) primitives: media queries, breakpoints,
+Ready-made [`foldkit-bundle`](../bundle) primitives: media queries, breakpoints,
 presence, timers, intervals, debounce, tweens, springs, pagination, history,
 locales, selections, ranges, geolocation, cameras, permissions, sockets,
 broadcasts, observers, and clipboard. Most are ordinary bundles — Model,
@@ -21,11 +21,15 @@ import { MediaQuery } from 'foldkit-primitives/media'
 A primitive belongs here when it is **reused across applications** and
 **stateful**: something observes it, something reacts to it, and replay sees
 the same transitions. That is exactly the bundle shape, which is why this
-package depends on `foldkit-bundle` and nothing else (besides peers).
+package depends on `foldkit-bundle` and nothing else (besides peers). The one
+exception is `interaction`, whose Bundles ship with a `foldkit-mixins` Behavior
+that wires them to a view's slots; `foldkit-mixins` is an optional peer that
+only that subpath needs.
 
 | Kind | Form | Example |
 | --- | --- | --- |
 | Stateful + effectful | bundle | MediaQuery, Timer, WebSocket, Pagination |
+| Interaction state a view's slots must reflect | bundle + Behavior | RovingTabindex, Typeahead, ListNavigation, GridNavigation, Press |
 | Keyed collections of stateful items | bundle per key | uploads, sockets, timers (later) |
 | Stream source with a stored fact | bundle with one boolean/scalar slice | Online, Visibility, WindowSize |
 | Stream source only | Subscription entry, not a bundle | keyboard, pointer, scroll, broadcast |
@@ -33,6 +37,15 @@ package depends on `foldkit-bundle` and nothing else (besides peers).
 | One-shot actions | Command, not a bundle | clipboard copy, share, script load |
 | Derived data | pure function, not a bundle | range, relative time, platform |
 
+Choose by what you need to own. State that outlives the moment — a match,
+a count, a page, a position — wants a bundle: the Model keeps it, replay
+sees it. A stream you only react to wants an entry: map it into the
+parent's Message and keep nothing. Work bound to one element wants a
+Mount. Work that runs once and reports back wants a Command. A value
+computed from data you already have wants a pure function. When in doubt,
+start with the lighter form; promote to a bundle the day the state needs
+a name in the Model.
+
 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.
@@ -48,14 +61,14 @@ accident — one state machine leaves nowhere for a second one to live.
 ```text
 browser / clock / server ──facts as Messages──▶ update ──▶ Model slice
                                                     ▲
-Note the direction: init is pure, so SSR renders the default; the stream corrects it live.
+The parent Model owns the recorded fact; subscriptions report environment changes.
 ```
 
-Every primitive follows one lifecycle: `init` returns a safe default without
-touching the environment (SSR-safe by construction). Streams report live
-facts — MediaQuery reads the current match first, then changes; Timer ticks
-while running. A primitive that cannot observe (no `window`, no API) yields
-an empty stream instead of throwing, so the slice keeps its default.
+Initialization creates the Model slice; subscriptions observe ongoing facts and
+report Messages; `update` stores them. Defaults differ by primitive:
+MediaQuery starts at `false`, while Online, Visibility, and Locale read an
+available platform value during initialization. Missing browser APIs have
+primitive-specific fallbacks; do not infer readiness from an SSR default.
 
 ## Install
 
@@ -69,49 +82,80 @@ pnpm add foldkit-primitives foldkit-bundle effect foldkit
 `foldkit-primitives/events`, `foldkit-primitives/observers`, `foldkit-primitives/dom` —
 so bundlers drop the primitives you never import.
 
+## Map of the package
+
+Each subpath is one concern, one import:
+
+- `media` — environment facts: MediaQuery (+presets), Breakpoints, platform
+- `net` — remote facts: Online, WebSocket, SSE, BroadcastChannel
+- `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
+- `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
+
 ## Sixty seconds: follow the color scheme
 
-**Declare where it lives.** A declaration names the Model field and the
-Message variant, by Foldkit's `Got<Field>Message` convention:
+**Place it in a parent.** `Bundle.compose` states the parent's own field and
+Message, and places the primitive under `dark`, with the wrapper Message
+`GotDarkMessage` by Foldkit's `Got<Field>Message` convention:
 
 ```ts
 import { Schema } from 'effect'
-import { defineMessageUnion } from 'foldkit/message'
+import type { HtmlBuilder } from 'foldkit/html'
 import { Bundle } from 'foldkit-bundle'
 import { MediaQuery } from 'foldkit-primitives/media'
 
-const Dark = Bundle.declare(MediaQuery, 'dark')
-
-const Model = Schema.Struct({ ...Dark.fields, theme: Schema.String })
-type Model = typeof Model.Type
-const Message = defineMessageUnion({ ...Dark.cases, ThemeSet: { theme: Schema.String } })
-type Message = typeof Message.Type
+const Page = Bundle.compose({ theme: Schema.String }).pipe(
+  Bundle.withMessages({ ThemeSet: { theme: Schema.String } }),
+  Bundle.withChild('dark', MediaQuery, { args: { query: '(prefers-color-scheme: dark)' } }),
+)
+type Model = typeof Page.Model.Type
+type Message = typeof Page.Message.Type
 ```
 
-**Place it.** The scope types everything from the parent's Schemas; the
-assembly derives the update and the Subscriptions:
+**Run it.** The parent's assembly derives the update and the Subscriptions:
 
 ```ts
-const Page = Bundle.parent({ Model, Message })
-const placements = Page.assemble(Page.at(Dark, { args: { query: '(prefers-color-scheme: dark)' } }))
+const { placements } = Page
 
 const config = placements.complete({
   init: () => placements.initial({ theme: 'light' }),
   update: placements.update(model => ({ model })),
-  view,
+  view: (model: Model, h: HtmlBuilder<Message>) =>
+    h.div([], [model.dark.matches ? 'Dark mode' : 'Light mode']),
   subscriptions: placements.subscriptions(),
 })
 ```
 
 `update` routes `GotDarkMessage` to the bundle; `subscriptions` runs the
 `matchMedia` stream; `initial` starts `matches` at `false` and the stream
-corrects it on subscribe. The Solid equivalent this replaces:
+corrects it on subscribe. None of these calls perform I/O: `compose` states
+the parent, `withChild` places the primitive with its config, and the
+assembly derives the folding and the streams. The browser is touched only
+when the runtime subscribes. The Solid equivalent this replaces:
 
 ```ts
 // solid-primitives: const dark = createMediaQuery('(prefers-color-scheme: dark)')
 // Here the fact lives in the Model: replay, DevTools, and time travel see it.
 ```
 
+## Composing placements
+
+One assembly holds every placement: spread its update, init,
+subscriptions, and resources once per application, as above. Two
+placements of one bundle observe twice — share the field instead, so one
+stream feeds every reader. One assembly holds one socket, stream, or
+watch: resource tags are per module, and `assemble` refuses the second.
+Bundles whose settled value is the whole point (`Debounce`, `Throttle`)
+surface it as an OutMessage the placement handles with `onOut`, so the
+signal can never be dropped by omission. Entries lift with
+`Subscription.persistent`, mapping into the parent's Message; Mounts
+attach in views with `h.OnMount`.
+
 ## Media: `foldkit-primitives/media`
 
 > Reference: [`./media/README.md`](./media/README.md)
@@ -126,7 +170,7 @@ Bound presets place with no args:
 ```ts
 import { PrefersDark, PrefersReducedMotion } from 'foldkit-primitives/media'
 
-const placements = Page.assemble(Page.place(PrefersDark, 'dark'))
+const Page = Bundle.compose({ theme: Schema.String }).pipe(Bundle.withChild('dark', PrefersDark))
 ```
 
 `Breakpoints` derives names from one `resize` listener: args
@@ -266,8 +310,7 @@ skipped. `Bounds()` re-measures `Measured { x, y, width, height }` on
 observer, scroll, and resize, starting with the current rect; without a
 ResizeObserver the window events still measure. Without the observer API
 (SSR, old browser) they emit nothing instead of throwing; teardown
-disconnects. They keep observing across time-travel pause — replay traffic
-is same-valued and harmless.
+disconnects. Treat repeated measurements as observations, not proof that a user action occurred.
 
 ## Device: `foldkit-primitives/device`
 
@@ -362,7 +405,7 @@ const Doc = Bundle.declare(EditHistory, 'doc')
 startup with the configured `default` as fallback; `SetLocale` switches it.
 `SelectionSet` keeps string ids in first-selection order: `Select` (keeps
 position), `Deselect`, `Toggle` (re-appends), `ReplaceAll` (deduped), and
-`Clear`. `isSelected` reads membership. Both are pure logic, no streams.
+`Clear`. `isSelected` reads membership. Neither subscribes to changes; Locale reads the initial browser language when available.
 Keyed children — lists with stable identity — place through the bundle
 mechanism's `each`.
 `range(start, end, step?)` counts half-open numbers — the pagination page
@@ -403,19 +446,20 @@ browser), restored through a `MirrorRestored` Message the application
 reduces. Nothing here duplicates it — reach for the mirror when a slice
 should survive reload, and keep this package's bundles for live facts.
 
-## With Surface and Mirror
-
-Placed state is ordinary Model, so the surrounding tools apply unchanged —
-no bundle-specific Surface or Mirror API exists, by design. Declare a Surface
-over the placed fields to render them or expose them to an agent; point
-`Mirror.url` at them to link them; spread the bundle's cases into the same
-unions. The field refs and wrapper Messages are the same ones the rest of the
-application uses.
-
 ## Motion: `foldkit-primitives/motion`
 
 > Reference: [`./motion/README.md`](./motion/README.md)
 
+Whether motion should be reduced is a service, `Motion`, read when a
+transition starts rather than sniffed once. `Presence` then exits at once,
+and `Tween` and `Spring` jump to `to`, in the same Messages, so the Model sees
+the same transitions. Provide `Motion.live` (the user's
+`prefers-reduced-motion`) through the assembly's resources, or `Motion.reduced`
+and `Motion.full` in a test or for a setting the application owns. With no
+service provided, motion is full, so a placement that provides nothing behaves
+as before. `Motion.reducedMotion` is the Effect the bundles read, for a
+transition of your own.
+
 `Tween` animates one number from `from` to `to` over `ms` milliseconds.
 Model `{ value, running }`, Messages `Started`/`Ticked`/`Finished`, args
 `{ from, to, ms }` (a non-positive or non-finite duration is rejected at
@@ -441,6 +485,274 @@ exact end value even when an underdamped spring overshoots on the way.
 `Tween` (fixed duration, linear) versus `Spring` (physics, settles) — pick
 the motion, not both.
 
+## Interaction: `foldkit-primitives/interaction`
+
+Interaction state that a view's slots must reflect: the Bundle holds it in the
+Model, and a matching [`foldkit-mixins`](../mixins) Behavior writes the
+attributes and handlers on the slots. Importing this subpath needs
+`foldkit-mixins`; the other subpaths do not.
+
+`RovingTabindex` is one tab stop for a set of items: arrows move focus between
+them, the rest stay out of the tab order. The Model slice is `{ current }`, the
+current item's **id**, so a reorder keeps the same item current and a resumed
+page knows where focus was. Args: `orientation` (`'vertical' | 'horizontal' |
+'both'`), `loop`, and `virtual` (focus stays on the container and
+`aria-activedescendant` points at the current item).
+
+```ts
+import { Bundle } from 'foldkit-bundle'
+import { Behavior, Behaviors, Capability, Slot, Slots, SlotView } from 'foldkit-mixins'
+import { RovingTabindex } from 'foldkit-primitives/interaction'
+
+const Roving = Bundle.declare(RovingTabindex.bundle, 'toolbarFocus')
+const Model = Schema.Struct({ ...Roving.fields, tools: Schema.Array(Tool) })
+const Message = defineMessageUnion({ ...Roving.cases })
+const Page = Bundle.parent({ Model, Message })
+const args = { orientation: 'horizontal', loop: true, virtual: false } as const
+const placements = Page.assemble(Page.at(Roving, { args }))
+
+const ToolbarSlots = Slots.define({
+  root: Slot.make({ capability: Capability.Container }),
+  tool: Slot.make({ capability: Capability.Focusable }),
+})
+const describeTools = (tools: ReadonlyArray<Tool>) =>
+  Behaviors.Collection.of(tools, { id: tool => tool.id, disabled: tool => tool.disabled })
+
+// Ids on each item come from Collection; RovingTabindex reads them.
+const Ids = Behaviors.Collection.behavior(ToolbarSlots)<Model, Message>({
+  item: 'tool',
+  items: model => describeTools(model.tools),
+})
+const Focus = RovingTabindex.behavior(Roving, args)(ToolbarSlots)<Model, Message>({
+  container: 'root',
+  item: 'tool',
+  items: model => describeTools(model.tools),
+})
+
+const Toolbar = SlotView.forMessages<Message>()
+  .define(ToolbarSlots, (model, slots, h) => {
+    const items = describeTools(model.tools)
+    return h.div(
+      slots.root.attrs([h.Role('toolbar')]),
+      model.tools.map((tool, index) =>
+        h.button(slots.tool.attrs([h.Key(tool.id)], items.slotItem(index)), [tool.label]),
+      ),
+    )
+  })
+  .pipe(Behavior.attach(Ids), Behavior.attach(Focus))
+```
+
+What each half does: the container gets `OnKeyDownFocus`, which on an arrow,
+Home or End focuses the next **enabled** item synchronously by its id, prevents
+the default, and dispatches `Focused { id }`. Each item gets `tabindex` `0` when
+it is the tab stop and `-1` otherwise, and `OnFocus` reporting `Focused`, so a
+click makes an item current too. Before anything is current, or when the
+current item is gone or disabled, the first enabled item is the tab stop. Keys
+with ctrl, alt or meta held are left alone; `direction: model => 'rtl'` swaps
+left and right. The pure `move(enabled, current, key, modifiers, options)` and
+`tabStop(items, current)` are exported for a view that wires its own.
+
+Under `virtual` the items get no `tabindex`, the container gets
+`aria-activedescendant`, and a key keeps DOM focus where it is and only moves
+the pointer. Nothing is written on dispose: the attributes are data, so a view
+that no longer attaches the Behavior leaves no `tabindex` behind. PageUp and
+PageDown are handled when `move` is given a `page`; `ListNavigation` below
+does that.
+
+`Typeahead` is type-to-find for a host that has no roving tab stop, or whose
+focus is managed elsewhere. The Model slice is `{ query, generation }`:
+printable keys extend the query, a timer of `timeoutMs` on Effect's clock
+clears it (`generation` lets a superseded timer change nothing), and `Cleared`
+drops it on purpose. Which item a query picks is the pure
+`Typeahead.match(texts, enabled, query, current)`: one character, or one
+character repeated, starts *after* the current item so repeated presses cycle;
+a longer query starts *at* it, since the user is refining. Case and leading
+whitespace are ignored and disabled items are skipped. The Behavior
+(`Typeahead.behavior(Declared)(Slots)<Model, Message>({ host, items, text,
+current })`) gives the host `OnKeyDownFocus`: a printable key with no ctrl, alt
+or meta extends the query, focuses the match by id, and dispatches `Typed`;
+with no match the key is still recorded and focus stays put; a space with an
+empty query is left to the host.
+
+`ListNavigation` is what a list host takes when it wants both: arrows, Home,
+End, PageUp and PageDown by `page`, and typeahead, in **one placement**. It
+exists for two reasons. The resolver allows one owner per event on a slot, so
+`RovingTabindex` and `Typeahead` cannot both own the host's `OnKeyDownFocus`;
+and under `virtual` a typed key must move the pointer and extend the query in
+one transition, which two placements cannot do. Its Model slice is `{ current,
+query, generation }`, its args are `RovingTabindex`'s plus `timeoutMs` and
+`page`, and its Behavior takes `{ container, item, items, text, direction? }`.
+`Typed { char, match }` carries the item the query now picks, so `update` sets
+`current` and `query` together.
+
+```ts
+const Nav = Bundle.declare(ListNavigation.bundle, 'nav')
+// place with { args: { orientation: 'vertical', loop: false, virtual: false, timeoutMs: 500, page: 10 } }
+const Keys = ListNavigation.behavior(Nav, args)(ListSlots)<Model, Message>({
+  container: 'list',
+  item: 'option',
+  items: model => describeFruits(model.fruits),
+  text: (model, index) => model.fruits[index]?.label ?? '',
+})
+```
+
+`GridNavigation` is the two-dimensional counterpart for cells laid out in rows
+of `columns` (a calendar grid, a swatch picker, an emoji palette). Its Model
+slice and item attributes are `RovingTabindex`'s, so the two are
+interchangeable on a view; only the pure `move` differs. Left and right step
+within the row and up and down within the column, skipping disabled cells;
+under `wrap` a horizontal key continues into the next row and a vertical key
+into the next column, otherwise the key is consumed at the edge. Home and End
+are the row's first and last enabled cell, Ctrl+Home and Ctrl+End the grid's.
+RTL swaps left and right, and `virtual` works as it does for `RovingTabindex`.
+
+```ts
+const Cells = Bundle.declare(GridNavigation.bundle, 'cells')
+// place with { args: { columns: 7, wrap: false, virtual: false } }
+const Keys = GridNavigation.behavior(Cells, args)(CalendarSlots)<Model, Message>({
+  container: 'grid',
+  item: 'day',
+  items: model => describeDays(model.days),
+})
+```
+
+`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,
+Message>({ container, contain?, restore?, initialFocus? })` attaches it to a
+container slot. On insert the container focuses `initialFocus`, else its first
+tabbable descendant, else itself. With `contain` (default), Tab from the last
+tabbable wraps to the first, Shift+Tab from the first wraps to the last, and
+focus that lands outside comes straight back; Tab in the middle is the
+browser's. On unmount, with `restore` (default), focus returns to the element
+that had it, if it is still in the document. A native `<dialog>` does all of
+this itself; this is for a custom overlay, a menu, or a command palette.
+`tabbableWithin(element)` is exported: focusable, visible descendants with a
+non-negative `tabindex`, in order.
+
+`Press` turns pointer and keyboard activation of one element into one fact.
+Foldkit's declarative pointer attributes carry no button, pointer id, or click
+detail, so `Press.events` is a Mount that reports what the element saw
+(`PointerDown`, `PointerUp`, `PointerCancelled`, `KeyDown`, `KeyUp`,
+`Clicked`), and the Bundle's `update` decides: primary button only, one
+pointer at a time, `pointerleave` and `pointercancel` cancel, Enter and Space
+with a repeat ignored, a click with `detail` 0 (keyboard on a native control,
+or assistive technology) counts, and the ghost click that follows a touch is
+ignored inside a window of `clickSuppressionMs` that a Command on Effect's
+clock closes. Enter and Space are default-prevented on the element, so a
+native control does not also click and Space does not scroll. Activation is
+the OutMessage `Pressed { pointerType, shiftKey }`, and the placement must handle it:
+
+```ts
+const Button = Bundle.declare(Press.bundle, 'saveButton')
+const placements = Page.assemble(
+  Page.at(Button, {
+    args: { clickSuppressionMs: 50 },
+    onOut: () => model => ({ model, commands: [save(model)] }),
+  }),
+)
+const Activate = Press.behavior(Button)(CardSlots)<Model, Message>({
+  target: 'save',
+  disabled: model => model.saving,
+})
+```
+
+The Behavior attaches the Mount to the target slot, writes `data-pressed`
+while the element is down for styling, and marks a disabled target
+`aria-disabled`, which the Mount reads at event time so nothing is reported
+and no remount is needed. The Model slice is `{ pressed, pointerId, key,
+suppressing, generation }`; only `pressed` is meant for a view.
+
+`LongPress` is holding for `thresholdMs`. It reads the same facts
+`Press.events` reports, so it needs no Mount of its own; the threshold is a
+Command on Effect's clock carrying a generation, and a release before it fires
+makes its `Elapsed` a no-op. `LongPressed { pointerType }` is the OutMessage,
+required at placement. The Behavior writes `data-holding` while down. `Press`
+and `LongPress` on one slot are refused by the resolver, since both would mount
+`PressEvents`; a slot takes one of them.
+
+`Move` is pointer movement as facts, a Mount in `foldkit-primitives/dom`: a
+primary-button pointer down captures the pointer and reports `MoveStarted`,
+each move reports `Moved { deltaX, deltaY }` from where it went down, and up,
+cancel, or lost capture reports `MoveEnded { completed }`. A second pointer
+and a secondary button are ignored; capture is released with the Mount.
+`Move.behavior(Slots)<Input, Message>({ handle, toMessage })` attaches it to a
+`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`.
+
+`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
+alone says nothing) and `pointerdown`. `FocusVisible.behavior(Declared)(Slots)
+<Model, Message>({ target })` writes `data-focus-visible` on the target while
+the page is driven by keyboard, so a stylesheet shows a ring with
+`[data-focus-visible]:focus`. CSS `:focus-visible` does this with no Model at
+all; this is for a design system that must decide in the Model, or show the
+same answer somewhere other than the focused element.
+
+`DismissLayer` closes overlays that are not native `<dialog>` or `popover`
+elements: Escape closes the topmost open layer, and a pointer press closes
+the layers it is outside of. One Bundle, **placed once**, owns the document
+listeners; each layer's Behavior marks its container with
+`data-foldkit-plus-layer="<id>"` and its trigger with the matching trigger
+attribute. The stack is the DOM order of the marked elements at the moment of
+the event, so a layer takes part exactly while it is rendered and an `open`
+flag in the parent Model is its whole lifecycle; nothing registers. The rules,
+each a test: a press inside a parent layer is outside its children, so the
+parent stays and the children go; a press on a layer's trigger counts as
+inside it, so a click on the trigger never dismisses and reopens; a layer
+placed with `outsidePress: false` or `escape: false` opts out of that path.
+`Dismiss { ids }` is the OutMessage, and the placement's `onOut` closes them:
+
+```ts
+const Layers = Bundle.declare(DismissLayer.bundle, 'layers')
+const placements = Page.assemble(
+  Page.at(Layers, {
+    onOut: ({ ids }) => model => ({ model: { ...model, menuOpen: ids.includes('menu') ? false : model.menuOpen } }),
+  }),
+)
+const Dismissable = DismissLayer.behavior(Layers)(MenuSlots)<Model, Message>({
+  layer: 'panel',
+  trigger: 'button',
+  id: () => 'menu',
+})
+```
+
+The Model slice is `{ layers }`, the open layers as the last event saw them,
+for DevTools and agents. `toDismiss(layers, inside)` is the pure rule.
+
+`Layers.scrollLock(Slots)({ container })` and `Layers.hideOutside(Slots)({
+container })` are Mounts over Foldkit's own `Dom.lockScroll` and
+`Dom.inertOthers`: the first locks the document's scroll while the container is
+mounted, refcounted so nested overlays release together, with Foldkit's iOS
+handling; the second marks everything outside the container inert while it is
+mounted, keyed by an id the Mount mints so two overlays restore independently.
+Both live in `foldkit-primitives/dom` as `ScrollLock` and `HideOutside`. A
+native `<dialog>` shown modally needs neither.
+
+`Selection` is which items are selected, with `mode` `'single'` (a click
+replaces; `allowEmpty` says whether clicking the selected item deselects it),
+`'multiple'` (a click toggles), or `'none'`, and the `anchor` a range extends
+from. The Model slice is `{ selected, anchor }`. A range needs the items'
+order, which the view knows and the Bundle does not, so `Ranged { id, order }`
+carries it; `Selection.between(order, from, to)` is the pure span. The Behavior
+(`Selection.behavior(Declared, args)(Slots)<Model, Message>({ container?,
+item, items, click? })`) writes `aria-selected` on each item and
+`aria-multiselectable` on the container, and wires a plain click on each
+enabled item to `Activated`; pass `click: false` when `Press` or the view owns
+the click. For a Shift range, `Press`'s `Pressed { pointerType, shiftKey }`
+says whether Shift was held, and the placement's `onOut` dispatches `Ranged`.
+
+`LiveAnnounce` speaks to assistive technology: one Bundle, placed once, holds
+the text of a polite and an assertive live region. `say(Declared)(text,
+politeness?)` builds the Message to return from `update` or an `onOut`; an
+announcement waits `debounceMs` so a burst reads once, then clears after
+`clearAfterMs`, both on Effect's clock with a generation so a superseded timer
+changes nothing; the same text twice gets a trailing no-break space toggled,
+which is what makes a screen reader read it again. `LiveAnnounce.view(slice,
+h)` renders the two regions: put it once in the page and hide them visually
+with a rule on `[data-foldkit-plus-live]`, never `display: none`.
+
 ## Testing placements
 
 Every primitive is testable without the platform, following one pattern
@@ -455,6 +767,15 @@ forking before the first `TestClock.adjust`, or dispatched events hit
 unregistered listeners. Each ingredient is demonstrated in this package's
 `test/` directory, named after its primitive.
 
+## With Surface and Mirror
+
+Placed state is ordinary Model, so the surrounding tools apply unchanged —
+no bundle-specific Surface or Mirror API exists, by design. Declare a Surface
+over the placed fields to render them or expose them to an agent; point
+`Mirror.url` at them to link them; spread the bundle's cases into the same
+unions. The field refs and wrapper Messages are the same ones the rest of the
+application uses.
+
 ## Failure and recovery
 
 | Failure | Behaviour |
@@ -463,7 +784,7 @@ unregistered listeners. Each ingredient is demonstrated in this package's
 | A Command without its platform API | failure Message (`CopyFailed`, `ShareFailed`, `BroadcastFailed`), never a throw |
 | Listener removed (unmount, gate closed) | finalizer disconnects; resubscribing re-reads the current value |
 | A Message for an unplaced child | never routes: wrappers only match placed variants |
-| A failing device (denied camera, unknown permission) | parks at `denied`/`idle` with requirements cleared: no acquire loop |
+| MediaStream acquisition fails | parks at `denied`/`idle` with requirements cleared; `Started` retries |
 
 ## Limits
 

package/dist/device/index.d.mts

@@ -292,6 +292,8 @@ export declare const permissions: <const Name extends string>(config: {
   };
   readonly lastError: string | null;
 }, {
+  readonly _tag: "Cleared";
+} | {
   readonly _tag: "Changed";
   readonly name: string;
   readonly state: "granted" | "denied" | "prompt";
@@ -303,8 +305,6 @@ export declare const permissions: <const Name extends string>(config: {
   readonly states: {
     readonly [x: string]: "granted" | "denied" | "prompt";
   };
-} | {
-  readonly _tag: "Cleared";
 }, never, never, ManagedResource.ManagedResourceService<"permissions">, void, Readonly<{
   watch: ManagedResource.Entry<PermissionsModel, PermissionsMessage, Option.Option<ReadonlyArray<string>>, Acquired, WatchService, (acquired: Acquired) => PermissionsMessage>;
 }>, {}>;

package/dist/dom/index.d.mts

@@ -1,3 +1,4 @@
+import { a as Moved, c as FocusScope, i as MoveStarted, l as tabbableWithin, n as Move, o as HideOutside, r as MoveEnded, s as ScrollLock, t as Fact } from "../move-DNiMPcuf.mjs";
 import { Schema } from "effect";
 import * as Mount from "foldkit/mount";
 import { Command } from "foldkit/command";
@@ -70,4 +71,5 @@ export type ShareMessage = typeof ShareMessage.Type;
 /** Shares data through the platform sheet. */
 export declare const share: (data: ShareData) => Command<ShareMessage, never, never>;
 //#endregion
+export { Fact, FocusScope, HideOutside, Move, MoveEnded, MoveStarted, Moved, ScrollLock, tabbableWithin };
 //# sourceMappingURL=index.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/dom/autofocus.ts","../../src/dom/clipboard.ts","../../src/dom/input-mask.ts","../../src/dom/script-loader.ts","../../src/dom/share.ts"],"mappings":";;;;qBAUa,SAAO,OAAA;YACR,iBAAiB,QAAQ;qBAExB,WAAS,MAAA;;;;;qBCJT,4CAAgB;;;sBAAhB,OAAA;;;YAID,0BAA0B,iBAAiB;;;;;;qBAU1C,WAAY,iBAAe,QAAQ;;;qBCXnC,OAAK,OAAA;;;;YAIN,eAAe,MAAM;qBA2BpB,YACX,eACA;WACY;WAAyB;;qBAoC1B,WAAS,MAAA;;;;;;;;;qBCvET,yCAAa;;;sBAAb,OAAA;;;YAID,uBAAuB,cAAc;;qBASpC,aAAc,gBAAc,QAAQ;;;qBCbpC,WAAS,OAAA;;;;;YAKV,mBAAmB,UAAU;qBAE5B,wCAAY;;;;sBAAZ,OAAA;;;YAKD,sBAAsB,aAAa;;qBAUlC,QAAS,MAAM,cAAY,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/dom/autofocus.ts","../../src/dom/clipboard.ts","../../src/dom/input-mask.ts","../../src/dom/script-loader.ts","../../src/dom/share.ts"],"mappings":";;;;;qBAUa,SAAO,OAAA;YACR,iBAAiB,QAAQ;qBAExB,WAAS,MAAA;;;;;qBCJT,4CAAgB;;;sBAAhB,OAAA;;;YAID,0BAA0B,iBAAiB;;;;;;qBAU1C,WAAY,iBAAe,QAAQ;;;qBCXnC,OAAK,OAAA;;;;YAIN,eAAe,MAAM;qBA2BpB,YACX,eACA;WACY;WAAyB;;qBAoC1B,WAAS,MAAA;;;;;;;;;qBCvET,yCAAa;;;sBAAb,OAAA;;;YAID,uBAAuB,cAAc;;qBASpC,aAAc,gBAAc,QAAQ;;;qBCbpC,WAAS,OAAA;;;;;YAKV,mBAAmB,UAAU;qBAE5B,wCAAY;;;;sBAAZ,OAAA;;;YAKD,sBAAsB,aAAa;;qBAUlC,QAAS,MAAM,cAAY,QAAQ"}

package/dist/dom/index.mjs

@@ -1,3 +1,4 @@
+import { a as HideOutside, c as tabbableWithin, i as Moved, n as MoveEnded, o as ScrollLock, r as MoveStarted, s as FocusScope, t as Move } from "../move-CZwHyTGk.mjs";
 import { Effect, Queue, Schema, Stream } from "effect";
 import * as Mount from "foldkit/mount";
 import { defineMessageUnion } from "foldkit/message";
@@ -213,6 +214,6 @@ const share = (data) => ({
 	}) : Effect.succeed(ShareMessage.ShareFailed({ message: "share is unavailable" }))
 });
 //#endregion
-export { Autofocus, ClipboardMessage, Focused, Input, InputMask, ScriptMessage, ShareData, ShareMessage, applyMask, copyText, loadScript, share };
+export { Autofocus, ClipboardMessage, FocusScope, Focused, HideOutside, Input, InputMask, Move, MoveEnded, MoveStarted, Moved, ScriptMessage, ScrollLock, ShareData, ShareMessage, applyMask, copyText, loadScript, share, tabbableWithin };
 
 //# sourceMappingURL=index.mjs.map

package/dist/dom/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["failMessage","failMessage"],"sources":["../../src/dom/autofocus.ts","../../src/dom/clipboard.ts","../../src/dom/input-mask.ts","../../src/dom/script-loader.ts","../../src/dom/share.ts"],"sourcesContent":["/**\n * Autofocus as a Mount: focuses the element on insert, then emits `Focused`.\n * The message means focus was requested — a non-focusable element or a\n * hidden tab may decline, and the browser does not report that. Plain\n * `focus()`, no scroll options: scroll behavior stays the application's\n * choice.\n */\nimport { Effect, Schema } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Focused = Schema.TaggedStruct('Focused', {})\nexport type Focused = typeof Focused.Type\n\nexport const Autofocus = Mount.define('Autofocus', {\n  messages: [Focused],\n  execute: ({ element }) =>\n    Effect.sync(() => {\n      const focusable = element as unknown as { readonly focus?: unknown }\n      if (typeof focusable.focus === 'function') {\n        ;(focusable.focus as () => void).call(element)\n      }\n      return Focused.make({})\n    }),\n})\n","/**\n * Clipboard copy as a Command: runs in `update` beside any bundle, yields\n * `Copied` on success and `CopyFailed` otherwise. No Model involved: the\n * clipboard is not application state.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ClipboardMessage = defineMessageUnion({\n  Copied: {},\n  CopyFailed: { message: Schema.String },\n})\nexport type ClipboardMessage = typeof ClipboardMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\n/**\n * Copies text to the clipboard. Without a clipboard API (SSR, insecure\n * context, denied permission) the command yields `CopyFailed` instead of\n * throwing, so `update` handles both outcomes as Messages.\n */\nexport const copyText = (text: string): Command<ClipboardMessage, never, never> => ({\n  name: 'Clipboard.copy',\n  args: { text },\n  effect:\n    typeof navigator !== 'undefined' && typeof navigator.clipboard?.writeText === 'function'\n      ? Effect.matchEffect(\n          Effect.tryPromise({\n            try: () => navigator.clipboard.writeText(text),\n            catch: failMessage,\n          }),\n          {\n            onFailure: message => Effect.succeed(ClipboardMessage.CopyFailed({ message })),\n            onSuccess: () => Effect.succeed(ClipboardMessage.Copied()),\n          },\n        )\n      : Effect.succeed(ClipboardMessage.CopyFailed({ message: 'clipboard is unavailable' })),\n})\n","/**\n * An input mask as a Mount plus a pure mask function. The pattern language\n * is three placeholders — `#` digit, `A` letter, `*` either, all ASCII —\n * with every other character literal. Literals appear only once a later placeholder\n * consumes input, so partial values never dangle a separator. The Mount\n * rewrites the field, restores the caret approximately, and emits `Input`\n * with both the masked and raw values; the parent owns the state, like any\n * controlled input.\n */\nimport { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Input = Schema.TaggedStruct('Input', {\n  value: Schema.String,\n  raw: Schema.String,\n})\nexport type Input = typeof Input.Type\n\nconst isDigit = (char: string): boolean => char >= '0' && char <= '9'\nconst isLetter = (char: string): boolean =>\n  (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')\n\nconst matches = (placeholder: string, char: string): boolean =>\n  placeholder === '#'\n    ? isDigit(char)\n    : placeholder === 'A'\n      ? isLetter(char)\n      : isDigit(char) || isLetter(char)\n\nconst isPlaceholder = (char: string): boolean => char === '#' || char === 'A' || char === '*'\n\n/** Whether any placeholder at or after `from` consumes any input at or after `at`. */\nconst fillable = (pattern: string, from: number, value: string, at: number): boolean => {\n  for (let i = from; i < pattern.length; i++) {\n    const placeholder = pattern[i]!\n    if (!isPlaceholder(placeholder)) continue\n    for (let j = at; j < value.length; j++) {\n      if (matches(placeholder, value[j]!)) return true\n    }\n  }\n  return false\n}\n\nexport const applyMask = (\n  value: string,\n  pattern: string,\n): { readonly masked: string; readonly raw: string } => {\n  let masked = ''\n  let raw = ''\n  let at = 0\n  for (let i = 0; i < pattern.length; i++) {\n    const slot = pattern[i]!\n    if (isPlaceholder(slot)) {\n      while (at < value.length && !matches(slot, value[at]!)) at++\n      if (at >= value.length) break\n      masked += value[at]!\n      raw += value[at]!\n      at++\n    } else if (fillable(pattern, i + 1, value, at)) {\n      masked += slot\n    } else {\n      break\n    }\n  }\n  return { masked, raw }\n}\n\ninterface MaskableField {\n  value: string\n  selectionStart: number | null\n  addEventListener(type: string, listener: () => void): void\n  removeEventListener(type: string, listener: () => void): void\n  setSelectionRange?(start: number, end: number): void\n}\n\nconst asField = (element: Element): MaskableField | null => {\n  const field = element as unknown as Partial<MaskableField>\n  return typeof field.value === 'string' && typeof field.addEventListener === 'function'\n    ? (field as MaskableField)\n    : null\n}\n\nexport const InputMask = Mount.defineStream('InputMask', {\n  messages: [Input],\n  args: { pattern: Schema.String },\n  execute: ({ element, pattern }) =>\n    Stream.callback<typeof Input.Type>(queue =>\n      Effect.gen(function* () {\n        const field = asField(element)\n        if (field === null) return\n        const onInput = () => {\n          const { masked, raw } = applyMask(field.value, pattern)\n          if (masked !== field.value) {\n            const caret = field.selectionStart ?? masked.length\n            field.value = masked\n            const at = Math.min(caret, masked.length)\n            try {\n              field.setSelectionRange?.(at, at)\n            } catch {\n              // Select-all style inputs reject ranges; the value still stands.\n            }\n          }\n          Queue.offerUnsafe(queue, Input.make({ value: masked, raw }))\n        }\n        yield* Effect.acquireRelease(\n          Effect.sync(() => {\n            field.addEventListener('input', onInput)\n            return field\n          }),\n          current => Effect.sync(() => current.removeEventListener('input', onInput)),\n        )\n      }),\n    ),\n})\n","/**\n * Script loading as a Command: appends a `src` script to the head unless one\n * is already there. Idempotent by URL — concurrent placements collapse onto\n * the first tag instead of fetching twice. Yields `Loaded` on success and\n * `LoadFailed` otherwise (network error, no document), so `update` handles\n * both outcomes as Messages.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ScriptMessage = defineMessageUnion({\n  Loaded: {},\n  LoadFailed: { message: Schema.String },\n})\nexport type ScriptMessage = typeof ScriptMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\n// Tags still fetching, by URL: concurrent loads share one tag and its fate.\nconst inflight = new Map<string, Promise<void>>()\n\n/** Loads a script by URL, once per URL. */\nexport const loadScript = (src: string): Command<ScriptMessage, never, never> => ({\n  name: 'Script.load',\n  args: { src },\n  effect: Effect.matchEffect(\n    Effect.tryPromise({\n      try: () => {\n        if (typeof document === 'undefined') {\n          return Promise.reject(new Error('script loading is unavailable'))\n        }\n        // Concurrent loads share one tag and its fate, instead of racing\n        // past the presence check and fetching twice: the in-flight entry\n        // is checked before presence, in the same synchronous block that\n        // appends, so a second load cannot slip between them.\n        const running = inflight.get(src)\n        if (running !== undefined) return running\n        // getAttribute, not .src: the property resolves to an absolute URL\n        // and would never equal the given string.\n        const present = Array.from(document.getElementsByTagName('script')).some(\n          element => element.getAttribute('src') === src,\n        )\n        if (present) return Promise.resolve()\n        const completion = new Promise<void>((resolve, reject) => {\n          const element = document.createElement('script')\n          element.src = src\n          element.async = true\n          element.onload = () => resolve()\n          element.onerror = () => {\n            // A dead tag must not satisfy later presence checks.\n            element.remove()\n            reject(new Error(`failed to load script: ${src}`))\n          }\n          document.head.appendChild(element)\n        })\n        const tracked = completion.then(\n          () => {\n            inflight.delete(src)\n          },\n          (error: unknown) => {\n            inflight.delete(src)\n            throw error\n          },\n        )\n        inflight.set(src, tracked)\n        return tracked\n      },\n      catch: (error: unknown) => error,\n    }),\n    {\n      onFailure: error => Effect.succeed(ScriptMessage.LoadFailed({ message: failMessage(error) })),\n      onSuccess: () => Effect.succeed(ScriptMessage.Loaded()),\n    },\n  ),\n})\n","/**\n * Web Share as a Command: runs in `update` beside any bundle, yields\n * `Shared` on success. Dismissal is its own outcome, not a failure — the\n * application tells a cancelled sheet apart from a broken one. Without a\n * share API (desktop, insecure context) it yields `ShareFailed` instead of\n * throwing, so `update` handles every outcome as a Message.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ShareData = Schema.Struct({\n  title: Schema.optional(Schema.String),\n  text: Schema.optional(Schema.String),\n  url: Schema.optional(Schema.String),\n})\nexport type ShareData = typeof ShareData.Type\n\nexport const ShareMessage = defineMessageUnion({\n  Shared: {},\n  Dismissed: {},\n  ShareFailed: { message: Schema.String },\n})\nexport type ShareMessage = typeof ShareMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst isDismissal = (error: unknown): boolean =>\n  typeof (error as { readonly name?: unknown } | null)?.name === 'string' &&\n  (error as { readonly name: string }).name === 'AbortError'\n\n/** Shares data through the platform sheet. */\nexport const share = (data: ShareData): Command<ShareMessage, never, never> => ({\n  name: 'Share.share',\n  args: { data },\n  effect:\n    typeof navigator !== 'undefined' && typeof navigator.share === 'function'\n      ? Effect.matchEffect(\n          Effect.tryPromise({\n            // Omit absent fields: the platform type rejects explicit\n            // undefined under exactOptionalPropertyTypes.\n            try: () =>\n              navigator.share({\n                ...(data.title !== undefined ? { title: data.title } : {}),\n                ...(data.text !== undefined ? { text: data.text } : {}),\n                ...(data.url !== undefined ? { url: data.url } : {}),\n              }),\n            catch: (error: unknown) => error,\n          }),\n          {\n            onFailure: error =>\n              Effect.succeed(\n                isDismissal(error)\n                  ? ShareMessage.Dismissed()\n                  : ShareMessage.ShareFailed({ message: failMessage(error) }),\n              ),\n            onSuccess: () => Effect.succeed(ShareMessage.Shared()),\n          },\n        )\n      : Effect.succeed(ShareMessage.ShareFailed({ message: 'share is unavailable' })),\n})\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["failMessage","failMessage"],"sources":["../../src/dom/autofocus.ts","../../src/dom/clipboard.ts","../../src/dom/input-mask.ts","../../src/dom/script-loader.ts","../../src/dom/share.ts"],"sourcesContent":["/**\n * Autofocus as a Mount: focuses the element on insert, then emits `Focused`.\n * The message means focus was requested — a non-focusable element or a\n * hidden tab may decline, and the browser does not report that. Plain\n * `focus()`, no scroll options: scroll behavior stays the application's\n * choice.\n */\nimport { Effect, Schema } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Focused = Schema.TaggedStruct('Focused', {})\nexport type Focused = typeof Focused.Type\n\nexport const Autofocus = Mount.define('Autofocus', {\n  messages: [Focused],\n  execute: ({ element }) =>\n    Effect.sync(() => {\n      const focusable = element as unknown as { readonly focus?: unknown }\n      if (typeof focusable.focus === 'function') {\n        ;(focusable.focus as () => void).call(element)\n      }\n      return Focused.make({})\n    }),\n})\n","/**\n * Clipboard copy as a Command: runs in `update` beside any bundle, yields\n * `Copied` on success and `CopyFailed` otherwise. No Model involved: the\n * clipboard is not application state.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ClipboardMessage = defineMessageUnion({\n  Copied: {},\n  CopyFailed: { message: Schema.String },\n})\nexport type ClipboardMessage = typeof ClipboardMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\n/**\n * Copies text to the clipboard. Without a clipboard API (SSR, insecure\n * context, denied permission) the command yields `CopyFailed` instead of\n * throwing, so `update` handles both outcomes as Messages.\n */\nexport const copyText = (text: string): Command<ClipboardMessage, never, never> => ({\n  name: 'Clipboard.copy',\n  args: { text },\n  effect:\n    typeof navigator !== 'undefined' && typeof navigator.clipboard?.writeText === 'function'\n      ? Effect.matchEffect(\n          Effect.tryPromise({\n            try: () => navigator.clipboard.writeText(text),\n            catch: failMessage,\n          }),\n          {\n            onFailure: message => Effect.succeed(ClipboardMessage.CopyFailed({ message })),\n            onSuccess: () => Effect.succeed(ClipboardMessage.Copied()),\n          },\n        )\n      : Effect.succeed(ClipboardMessage.CopyFailed({ message: 'clipboard is unavailable' })),\n})\n","/**\n * An input mask as a Mount plus a pure mask function. The pattern language\n * is three placeholders — `#` digit, `A` letter, `*` either, all ASCII —\n * with every other character literal. Literals appear only once a later placeholder\n * consumes input, so partial values never dangle a separator. The Mount\n * rewrites the field, restores the caret approximately, and emits `Input`\n * with both the masked and raw values; the parent owns the state, like any\n * controlled input.\n */\nimport { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Input = Schema.TaggedStruct('Input', {\n  value: Schema.String,\n  raw: Schema.String,\n})\nexport type Input = typeof Input.Type\n\nconst isDigit = (char: string): boolean => char >= '0' && char <= '9'\nconst isLetter = (char: string): boolean =>\n  (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')\n\nconst matches = (placeholder: string, char: string): boolean =>\n  placeholder === '#'\n    ? isDigit(char)\n    : placeholder === 'A'\n      ? isLetter(char)\n      : isDigit(char) || isLetter(char)\n\nconst isPlaceholder = (char: string): boolean => char === '#' || char === 'A' || char === '*'\n\n/** Whether any placeholder at or after `from` consumes any input at or after `at`. */\nconst fillable = (pattern: string, from: number, value: string, at: number): boolean => {\n  for (let i = from; i < pattern.length; i++) {\n    const placeholder = pattern[i]!\n    if (!isPlaceholder(placeholder)) continue\n    for (let j = at; j < value.length; j++) {\n      if (matches(placeholder, value[j]!)) return true\n    }\n  }\n  return false\n}\n\nexport const applyMask = (\n  value: string,\n  pattern: string,\n): { readonly masked: string; readonly raw: string } => {\n  let masked = ''\n  let raw = ''\n  let at = 0\n  for (let i = 0; i < pattern.length; i++) {\n    const slot = pattern[i]!\n    if (isPlaceholder(slot)) {\n      while (at < value.length && !matches(slot, value[at]!)) at++\n      if (at >= value.length) break\n      masked += value[at]!\n      raw += value[at]!\n      at++\n    } else if (fillable(pattern, i + 1, value, at)) {\n      masked += slot\n    } else {\n      break\n    }\n  }\n  return { masked, raw }\n}\n\ninterface MaskableField {\n  value: string\n  selectionStart: number | null\n  addEventListener(type: string, listener: () => void): void\n  removeEventListener(type: string, listener: () => void): void\n  setSelectionRange?(start: number, end: number): void\n}\n\nconst asField = (element: Element): MaskableField | null => {\n  const field = element as unknown as Partial<MaskableField>\n  return typeof field.value === 'string' && typeof field.addEventListener === 'function'\n    ? (field as MaskableField)\n    : null\n}\n\nexport const InputMask = Mount.defineStream('InputMask', {\n  messages: [Input],\n  args: { pattern: Schema.String },\n  execute: ({ element, pattern }) =>\n    Stream.callback<typeof Input.Type>(queue =>\n      Effect.gen(function* () {\n        const field = asField(element)\n        if (field === null) return\n        const onInput = () => {\n          const { masked, raw } = applyMask(field.value, pattern)\n          if (masked !== field.value) {\n            const caret = field.selectionStart ?? masked.length\n            field.value = masked\n            const at = Math.min(caret, masked.length)\n            try {\n              field.setSelectionRange?.(at, at)\n            } catch {\n              // Select-all style inputs reject ranges; the value still stands.\n            }\n          }\n          Queue.offerUnsafe(queue, Input.make({ value: masked, raw }))\n        }\n        yield* Effect.acquireRelease(\n          Effect.sync(() => {\n            field.addEventListener('input', onInput)\n            return field\n          }),\n          current => Effect.sync(() => current.removeEventListener('input', onInput)),\n        )\n      }),\n    ),\n})\n","/**\n * Script loading as a Command: appends a `src` script to the head unless one\n * is already there. Idempotent by URL — concurrent placements collapse onto\n * the first tag instead of fetching twice. Yields `Loaded` on success and\n * `LoadFailed` otherwise (network error, no document), so `update` handles\n * both outcomes as Messages.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ScriptMessage = defineMessageUnion({\n  Loaded: {},\n  LoadFailed: { message: Schema.String },\n})\nexport type ScriptMessage = typeof ScriptMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\n// Tags still fetching, by URL: concurrent loads share one tag and its fate.\nconst inflight = new Map<string, Promise<void>>()\n\n/** Loads a script by URL, once per URL. */\nexport const loadScript = (src: string): Command<ScriptMessage, never, never> => ({\n  name: 'Script.load',\n  args: { src },\n  effect: Effect.matchEffect(\n    Effect.tryPromise({\n      try: () => {\n        if (typeof document === 'undefined') {\n          return Promise.reject(new Error('script loading is unavailable'))\n        }\n        // Concurrent loads share one tag and its fate, instead of racing\n        // past the presence check and fetching twice: the in-flight entry\n        // is checked before presence, in the same synchronous block that\n        // appends, so a second load cannot slip between them.\n        const running = inflight.get(src)\n        if (running !== undefined) return running\n        // getAttribute, not .src: the property resolves to an absolute URL\n        // and would never equal the given string.\n        const present = Array.from(document.getElementsByTagName('script')).some(\n          element => element.getAttribute('src') === src,\n        )\n        if (present) return Promise.resolve()\n        const completion = new Promise<void>((resolve, reject) => {\n          const element = document.createElement('script')\n          element.src = src\n          element.async = true\n          element.onload = () => resolve()\n          element.onerror = () => {\n            // A dead tag must not satisfy later presence checks.\n            element.remove()\n            reject(new Error(`failed to load script: ${src}`))\n          }\n          document.head.appendChild(element)\n        })\n        const tracked = completion.then(\n          () => {\n            inflight.delete(src)\n          },\n          (error: unknown) => {\n            inflight.delete(src)\n            throw error\n          },\n        )\n        inflight.set(src, tracked)\n        return tracked\n      },\n      catch: (error: unknown) => error,\n    }),\n    {\n      onFailure: error => Effect.succeed(ScriptMessage.LoadFailed({ message: failMessage(error) })),\n      onSuccess: () => Effect.succeed(ScriptMessage.Loaded()),\n    },\n  ),\n})\n","/**\n * Web Share as a Command: runs in `update` beside any bundle, yields\n * `Shared` on success. Dismissal is its own outcome, not a failure — the\n * application tells a cancelled sheet apart from a broken one. Without a\n * share API (desktop, insecure context) it yields `ShareFailed` instead of\n * throwing, so `update` handles every outcome as a Message.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ShareData = Schema.Struct({\n  title: Schema.optional(Schema.String),\n  text: Schema.optional(Schema.String),\n  url: Schema.optional(Schema.String),\n})\nexport type ShareData = typeof ShareData.Type\n\nexport const ShareMessage = defineMessageUnion({\n  Shared: {},\n  Dismissed: {},\n  ShareFailed: { message: Schema.String },\n})\nexport type ShareMessage = typeof ShareMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst isDismissal = (error: unknown): boolean =>\n  typeof (error as { readonly name?: unknown } | null)?.name === 'string' &&\n  (error as { readonly name: string }).name === 'AbortError'\n\n/** Shares data through the platform sheet. */\nexport const share = (data: ShareData): Command<ShareMessage, never, never> => ({\n  name: 'Share.share',\n  args: { data },\n  effect:\n    typeof navigator !== 'undefined' && typeof navigator.share === 'function'\n      ? Effect.matchEffect(\n          Effect.tryPromise({\n            // Omit absent fields: the platform type rejects explicit\n            // undefined under exactOptionalPropertyTypes.\n            try: () =>\n              navigator.share({\n                ...(data.title !== undefined ? { title: data.title } : {}),\n                ...(data.text !== undefined ? { text: data.text } : {}),\n                ...(data.url !== undefined ? { url: data.url } : {}),\n              }),\n            catch: (error: unknown) => error,\n          }),\n          {\n            onFailure: error =>\n              Effect.succeed(\n                isDismissal(error)\n                  ? ShareMessage.Dismissed()\n                  : ShareMessage.ShareFailed({ message: failMessage(error) }),\n              ),\n            onSuccess: () => Effect.succeed(ShareMessage.Shared()),\n          },\n        )\n      : Effect.succeed(ShareMessage.ShareFailed({ message: 'share is unavailable' })),\n})\n"],"mappings":"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"}