@gjermundgaraba-designs/pixel-paper 0.14.0 → 0.15.0

package/DESIGN.md

@@ -1055,11 +1055,11 @@ The printed button: a paper rectangle in a 2px ink frame that casts a 3px shadow
 
 ### Cards (dialogs)
 
-**Dialog** is a Submodel over `@foldkit/ui`'s Dialog: a `<dialog class="veil">` that fills the viewport, opened with `show()` in place rather than `showModal()` in the top layer. That is a deliberate exception to the baseline's "prefer the platform" for overlays: Foldkit's Dialog (through `Dom.showDialog`) makes everything outside the dialog `inert` and `aria-hidden`, traps focus, handles Escape on the topmost dialog and returns focus on close, so the platform's modal behaviour is reproduced, not dropped; what is lost is the top layer and its `::backdrop`. The veil is therefore an element of its own, `div.veil-backdrop` (fixed, Veil with the ink checker grain, entering in 3 steps over 0.12s), under `div.veil-pad` (`.top` for the palette), which lets a press through everywhere but on the card it holds; a press on the veil, Escape, or a control given the `closeButton` group closes it and reports `Closed`. While its work must land in it (a save whose failure the reader has to see), the update that starts the work holds those three in the dialog's Model (`Dialog.setCloseHeld`), so its update leaves them out, however soon after the start they come: it stays open and reports no `Closed`. The update where the work fails lets go (`Dialog.setCloseHeld(model, false)`), or the reader is shut in with the failure; `Dialog.close` closes it and lets go of the hold. Opening and closing are the parent's, through `Dialog.open` and `Dialog.close` in its update, and a step the parent asked for reports nothing; `Dialog.foldDialog` lifts a dialog the parent always holds (its update, `open` and `close`) into the parent at once, `Closed` reported only where the parent maps it. The content is the parent's `toView`, which receives the attribute groups to spread (`title`, `description`, `initialFocus`, `closeButton`, `actionBar`). Focus starts on the element given the `initialFocus` group, else the first control. The Card inside names the dialog through its title (the `title` group, `aria-labelledby`); a dialog without a heading takes `label`, printed for screen readers only. `isAlert` makes it an `alertdialog`, and `hasDescription` points `aria-describedby` at the element given the `description` group. Because the page outside is inert and hidden, anything that must be heard or reached while it is open renders inside it: the topmost open dialog hosts the page's live region and the toast stack, both outside the card, through its `toLiveRegionView` (see Building components).
+**Dialog** is a Submodel over `@foldkit/ui`'s Dialog: a `<dialog class="veil">` that fills the viewport, opened with `show()` in place rather than `showModal()` in the top layer. That is a deliberate exception to the baseline's "prefer the platform" for overlays: Foldkit's Dialog (through `Dom.showDialog`) makes everything outside the dialog `inert` and `aria-hidden`, traps focus, handles Escape on the topmost dialog and returns focus on close, so the platform's modal behaviour is reproduced, not dropped; what is lost is the top layer and its `::backdrop`. The veil is therefore an element of its own, `div.veil-backdrop` (fixed, Veil with the ink checker grain, entering in 3 steps over 0.12s), under `div.veil-pad` (`.top` for the palette), which lets a press through everywhere but on the card it holds; a press on the veil, Escape, or a control given the `closeButton` group closes it and reports `Closed`. While its work must land in it (a save whose failure the reader has to see), the parent holds those three: its update passes `isCloseHeld` to the dialog's (`Dialog.update(model, message, { isCloseHeld })`, or `foldDialog`'s `isCloseHeld: (model) => model.isSaving`), read from its own state as each Message arrives, so the hold starts with the work, ends with it, and covers a key pressed before the next render: the dialog stays open and reports no `Closed`. Nothing is stored, so there is nothing to let go of. Opening and closing are the parent's, through `Dialog.open` and `Dialog.close` in its update, and a step the parent asked for reports nothing; `Dialog.foldDialog` lifts a dialog the parent always holds (its update, `open` and `close`) into the parent at once, `Closed` reported only where the parent maps it. The content is the parent's `toView`, which receives the attribute groups to spread (`title`, `description`, `initialFocus`, `closeButton`, `actionBar`). Focus starts on the element given the `initialFocus` group, else the first control. The Card inside names the dialog through its title (the `title` group, `aria-labelledby`); a dialog without a heading takes `label`, printed for screen readers only. `isAlert` makes it an `alertdialog`, and `hasDescription` points `aria-describedby` at the element given the `description` group. Because the page outside is inert and hidden, anything that must be heard or reached while it is open renders inside it: the topmost open dialog hosts the page's live region and the toast stack, both outside the card, through its `toLiveRegionView` (see Building components).
 
-**Card** → `div.card` (`.narrow`; `form.card` from `Card.formView`, named by its title (`aria-label`), so a form landmark; no role of its own, the Dialog around it is the dialog): a paper panel with the card shadow, `min(680px, 100%)` (440px narrow), entering in 3 steps over 0.14s from `scale(0.97)`. An inverted title bar `header.card-tb` (`6px 8px 6px 12px`, 13px uppercase 0.06em (`--tracking-head`), a close IconButton when it has `closeAttributes`, held by `Card.formView`'s `isBusy` while work the reader may not walk away from runs: `aria-disabled`, in the keyboard, its `closeAttributes` and so its handler dropped, faded to 0.6 on the bar, as a held button in a panel's title bar), a scrolling `div.card-body` (16px, 14px gap; a word longer than the card, a path or an id, breaks rather than widening it), and `div.card-actions` (`12px 16px`) over a 2px ink rule: `lead` first, then `span.card-acts` holding the actions at the right, which drop below the lead together when the bar wraps. Inside a Dialog, where the page's keys wait, the bar moves focus between its actions: `h` or ← to the one before, `l` or → to the one after, in the order they print, stopping at the ends, never pressing one (Enter, Space and Tab stay the browser's). The keys are bound by a Mount on the bar (`BindActionKeys`), which reads the real key event: only a key whose target is one of that bar's own buttons or links, unmodified, outside an IME and not already handled, and only when there is an action that way, moves focus and has its default prevented. A field, the title bar's close, a menu's items and a nested dialog's bar keep their keys. A disabled action is passed over; an `aria-disabled` one (held: busy, done or disabled) is still a stop and still ignores presses. **Card.formView** is the one way to make a form card: its `body` in one Fields group, then the action bar's cancel (`cancel`, closing through `closeAttributes`) and the primary default submit button (`submit`, its id `Card.submitId(id)`). One flag, `isBusy`, holds every way the form could change or leave while its work runs: the submit button prints busy and turns `type="button"`, the close glyph and cancel are held with their close attributes dropped, and the Fields group is natively disabled and `aria-busy`, so nothing changes under the send and nothing sends twice. In a Dialog, the update that sends also holds the Dialog's ways out (`Dialog.setCloseHeld`), Escape and the veil among them, and the update where the send fails lets go of both, the reason on the field (the specimen's rename refuses a name with a slash). `isSubmitDisabled` holds the submit button alone while there is nothing to send (a name unchanged), the fields and cancel live. The fields leave the keyboard as they are held, so the update moves focus to the submit button as it sends (`Focus.Focus({ id: Card.submitId(id) })`), and it still ignores `onSubmit` while busy, for an Enter that raced the render. A ConfirmDialog with `isDanger` still opens on cancel.
+**Card** → `div.card` (`.narrow`; `form.card` from `Card.formView`, named by its title (`aria-label`), so a form landmark; no role of its own, the Dialog around it is the dialog): a paper panel with the card shadow, `min(680px, 100%)` (440px narrow), entering in 3 steps over 0.14s from `scale(0.97)`. An inverted title bar `header.card-tb` (`6px 8px 6px 12px`, 13px uppercase 0.06em (`--tracking-head`), a close IconButton when it has `closeAttributes`, held by `Card.formView`'s `isBusy` while work the reader may not walk away from runs: `aria-disabled`, in the keyboard, its `closeAttributes` and so its handler dropped, faded to 0.6 on the bar, as a held button in a panel's title bar), a scrolling `div.card-body` (16px, 14px gap; a word longer than the card, a path or an id, breaks rather than widening it), and `div.card-actions` (`12px 16px`) over a 2px ink rule: `lead` first, then `span.card-acts` holding the actions at the right, which drop below the lead together when the bar wraps. Inside a Dialog, where the page's keys wait, the bar moves focus between its actions: `h` or ← to the one before, `l` or → to the one after, in the order they print, stopping at the ends, never pressing one (Enter, Space and Tab stay the browser's). The keys are bound by a Mount on the bar (`BindActionKeys`), which reads the real key event: only a key whose target is one of that bar's own buttons or links, unmodified, outside an IME and not already handled, and only when there is an action that way, moves focus and has its default prevented. A field, the title bar's close, a menu's items and a nested dialog's bar keep their keys. A disabled action is passed over; an `aria-disabled` one (held: busy, done or disabled) is still a stop and still ignores presses. **Card.formView** is the one way to make a form card: its `body` in one Fields group, then the action bar's `lead` (a form's own delete, before the push), cancel (`cancel`, closing through `closeAttributes`) and the primary default submit button (`submit`, its id `Card.submitId(id)`). One flag, `isBusy`, holds every way the form could change or leave while its work runs: the submit button prints busy and turns `type="button"`, the close glyph and cancel are held with their close attributes dropped, and the Fields group is natively disabled and `aria-busy`, so nothing changes under the send and nothing sends twice. In a Dialog, the state that sets `isBusy` is the `isCloseHeld` the parent passes the Dialog's update, so Escape and the veil are held with it, and a failed send frees both, the reason on the field (the specimen's rename refuses a name with a slash). `notices` print above the Fields group, outside the hold: what the page says while the form is open (a lost connection with its retry), whose controls stay live while it sends. `isSubmitDisabled` holds the submit button alone while there is nothing to send (a name unchanged), the fields and cancel live. The fields leave the keyboard as they are held, so the update moves focus to the submit button as it sends (`Focus.Focus({ id: Card.submitId(id) })`), and it still ignores `onSubmit` while busy, for an Enter that raced the render. A ConfirmDialog with `isDanger` still opens on cancel.
 
-- **ConfirmDialog** → a Submodel over Dialog (an `alertdialog` when `isDanger`, a `dialog` otherwise) holding a narrow Card whose body is an Outcome (warn, or error when `isDanger`), the Outcome's body describing the dialog. Its view inputs follow the system's words: `title` (the title bar), `question` (the Outcome's title), `body`, and `label` (the confirming button's word). Without `isDanger` the confirm is primary and default; with it the confirm is the red button and cancel is the default, where focus starts. `Confirmed` does not close it: work that takes a while stays in the dialog. `isBusy` holds the confirming button (its word, the working cursor, focus kept, a second press ignored) while cancel stays live; the parent calls `ConfirmDialog.close` when the work lands, or keeps it open while it is not done. `isDisabled` holds it the same way without the working cursor, for an action that is blocked rather than running (writes not accepted yet). `toDetailView` prints the application's own content under the sentence, inside the Outcome's body and so in the dialog's description: what the work said back (a refused delete's reason as an error Notice) or a notice with its own retry. Cancel, Escape and the veil report `Cancelled`; the parent decides whether that also stops work already running, and ignores the work's result once cancelled. Where the reader may not walk away from the work (its failure must land in the dialog), the update that starts it holds the ways out (`ConfirmDialog.setCloseHeld`): cancel prints held (`aria-disabled`, in the keyboard, no ring and no shadow while the busy commit keeps focus), and cancel, Escape and a press on the veil change nothing, so the dialog stays open and reports no `Cancelled`; the update where the work fails lets go, and `close` closes it and lets go.
+- **ConfirmDialog** → a Submodel over Dialog (an `alertdialog` when `isDanger`, a `dialog` otherwise) holding a narrow Card whose body is an Outcome (warn, or error when `isDanger`), the Outcome's body describing the dialog. Its view inputs follow the system's words: `title` (the title bar), `question` (the Outcome's title), `body`, and `label` (the confirming button's word). Without `isDanger` the confirm is primary and default; with it the confirm is the red button and cancel is the default, where focus starts. `Confirmed` does not close it: work that takes a while stays in the dialog. `isBusy` holds the confirming button (its word, the working cursor, focus kept, a second press ignored) and cancel (`aria-disabled`, in the keyboard, no ring and no shadow while the busy commit keeps focus); the parent calls `ConfirmDialog.close` when the work lands, or keeps it open while it is not done. `isDisabled` holds it the same way without the working cursor, for an action that is blocked rather than running (writes not accepted yet). `toDetailView` prints the application's own content under the sentence, inside the Outcome's body and so in the dialog's description: what the work said back (a refused delete's reason as an error Notice) or a notice with its own retry. Cancel, Escape and the veil report `Cancelled`; the parent decides whether that also stops work already running, and ignores the work's result once cancelled. The parent passes the same state as `isCloseHeld` to `ConfirmDialog.update`, so cancel, Escape and a press on the veil change nothing while the work runs: the dialog stays open and reports no `Cancelled`, and the reader sees how it ends.
 - **CommandPalette** (Submodel over Dialog and `@foldkit/ui`'s Input with a listbox of its own, since a combobox would not let the cursor land on held rows or Escape reach the Dialog) → a card at 18vh holding `div.palette-q` (a `span.palette-scope` and a combobox input), `div.palette-detail` when the app gives `toDetailView`, `div.palette-list[role="listbox"]` of `div.palette-group` headings and `div.palette-row[role="option"][aria-selected]` rows (control register; `isAuthored` titles, `.authored`, set in sans with a glyph and wait for a query), a `div.sr-only[role="status"]`, and `div.palette-more`. Once a query is typed the status says how many rows it finds ("3 results.", "Nothing matches."); it is empty as the card opens and on a fresh page, so it is never mounted holding its words (rule 12). Labels and hints wrap within their row, including long names and destination paths. One cursor: the inverted row, moved by the keys only. ↑ ↓ move it and stop at the ends, each key one row from where the last left it however fast they come (the field's own handler, in the view, reports `PressedArrowKey` with the rows its render showed, and update steps from the Model's cursor); Home and End stay the field's, moving the caret; Enter does what a click on its row does, decided in update from what the render showed each row to be (held, opening a page, a choice on a page): a command closes the palette first so what it opens takes focus, and reports `SelectedCommand`. An arrow or an Enter pressed before the list has caught up with the keys before it (straight after a letter, or before the arrows already waiting have moved the cursor) cannot name a row yet, so it waits for the next render: the row that render shows the cursor on becomes the cursor, and a waiting Enter acts on it as on any row. So arrows typed straight after a letter step through the new query's rows, and an Enter acts on the keys before it, never on letters typed after it. While the palette is open, ↑ ↓ and Enter pressed before its field has focus (straight after the key that opened it) are its own too: `CommandPalette.subscriptions(keyPrefix)` takes them on the window before the page's bindings see them, and they wait as above. A key an IME is composing stays the IME's. The pointer shades the row under it (Header Grey, as a list's row) and a click runs that row; it never moves the cursor and never scrolls. The cursor comes into view on every key that moves it, when the view or the query changes, and when its row leaves the list (it falls back to the first): the app, which changes the list, returns `CommandPalette.ScrollToCursor` with the palette's id; a row that only reflows is not followed. The cursor holds to its row by id while the app updates the list; `CommandPalette.maybeCursorId` reads the row it shows for a list of commands, so the app can compare it before and after its change. A row with `isDisabled` prints muted (`[aria-disabled="true"]`), its `reason` in the hint, and the cursor still lands on it but Enter and a click do nothing. **Pages:** a command with a `page` (a status, a date, a destination) ends in a caret and opens that page in place instead of closing: `div.palette-q` holds a Back IconButton, the scope chip (what the commands act on, kept on every page), the page's title (`span.palette-title`, pixel caps), then the page's own field (placeholder `find`, else "type to narrow"), focused. A long scope wraps inside its chip and the field takes its own line when too little is left beside it, so nothing leaves the card at 390px. The choices are found in like the commands. The choice in force now (`current`) carries a `current` tag and cannot be picked again. The cursor starts on the page's `start` (the next status; the first choice a typed query finds), else on `current`, else on the first choice, read while the reader has not moved it, so an application that keeps `start` steady across a change made elsewhere moves the tag, not the cursor. Back, or Backspace in an empty field, returns to the commands with their query and cursor as they were, also when the palette opened straight on a page (`CommandPalette.openAt`). A pick (`SelectedChoice`) holds the page until the parent answers: the row prints the working cursor, the list is `aria-busy`, and moving, picking, typing and Back wait. With `CommandPalette.pickSucceeded` the palette closes; with `pickFailed` the page stays with its query, focus and the cursor on that choice, and the app says why in `toDetailView`, which shows on the commands and on every page alike. Escape closes the whole palette, even while a pick is out, and reports `Closed`; an answer arriving after that, or after the page was left, changes nothing. A page whose command leaves the list gives way to the commands. One level: choices do not open pages.
 - **Keymap** → `div.keymap > div > h3 + div.keymap-row > kbd + span`: keys in the 11px pixel face under 10px muted group heads, for a narrow Card.
 
@@ -1221,7 +1221,8 @@ Each component is `src/<name>/<name>.ts` with an explicit `index.ts`, a colocate
 15. **A Mount reports through the parent.** A View that owns a Mount takes a required `toParentMessage: (message: X.Message) => ParentMessage` (TopBar, StatusBar, Toolbar, the mermaid adapter), and a fire-and-forget Mount maps to a caller `Completed*` Message the parent may ignore. A bare `onX: Message` is used only where the parent's Model acts on the fact (ImageFrame's `onBroken`). In a Scene, resolve the Mount by name with the lifted Message: `Scene.Mount.resolve({ name: X.Mount.name }, toParentMessage(...))`. Where every application's Scene must resolve a component's Mounts to render a page at all, the namespace exports `sceneMounts`, the matchers paired with Messages that change nothing, for `Scene.Mount.resolveAll(...X.sceneMounts)`: `TopBar.sceneMounts(toParentMessage)`, `Toast.sceneMounts` and `Dialog.sceneMounts` (which serves ConfirmDialog, KeyHelp and CommandPalette too).
 16. **Fragment links focus through the application.** A link to `#id` (SkipLink, an ErrorSummary's links) needs the application's URL handler to return `SkipLink.ScrollToFragment` for the changed URL, since Foldkit routes the click.
 17. **Platform services are the application's.** A component that needs a platform service says so in its TSDoc and here (CopyButton writes through Effect's `Clipboard`), and the application provides the Layer in its `resources`.
-18. **Upstream gaps.** Where `@foldkit/ui` lacks a capability, the workaround carries `// NOTE: @foldkit/ui gap: <what>` at its site, and that note is the record: there is no list beside it. A wrapper that must build a child Message itself says so in the same note, with a lint disable on that line alone.
+18. **Held work gives up.** Work that holds a dialog's ways out (a save, a delete) waits on something outside the page, which can hang, and a hang would shut the reader in. Its Command ends in a timeout mapped to its failure Message (`Effect.timeoutOrElse({ duration, orElse: () => Effect.succeed(FailedSave({ … })) })`), so the hold always ends with the reason in the dialog.
+19. **Upstream gaps.** Where `@foldkit/ui` lacks a capability, the workaround carries `// NOTE: @foldkit/ui gap: <what>` at its site, and that note is the record: there is no list beside it. A wrapper that must build a child Message itself says so in the same note, with a lint disable on that line alone.
 
 ## Do's and Don'ts
 

package/dist/src/card/card.d.ts

@@ -24,13 +24,18 @@ export type ViewConfig<Message> = Readonly<{
 /** The raised surface: paper in a 2px ink box on the 8px print shadow, under a title bar. */
 export declare const view: <Message>(config: ViewConfig<Message>, h: HtmlBuilder<Message>) => Html;
 /** Configuration for rendering a form card with `formView`: a card's, but for its body, its
- *  close attributes and its action bar, which the form fills. */
-export type FormViewConfig<Message> = Omit<ViewConfig<Message>, "body" | "closeAttributes" | "actions" | "lead"> & Readonly<{
+ *  close attributes and its actions, which the form fills. `lead` stays the card's: what
+ *  goes before the push, such as a form's own delete. */
+export type FormViewConfig<Message> = Omit<ViewConfig<Message>, "body" | "closeAttributes" | "actions"> & Readonly<{
     /** Unique in the document: the submit button's id is `submitId(id)`. */
     id: string;
     /** The form's content, fields and all, in one Fields group that `isBusy` holds. A link in
      *  it (an ErrorSummary's) stays live. */
     body: ReadonlyArray<Html | string>;
+    /** Above the fields, outside the group `isBusy` holds: what the page says about the form
+     *  while it is open (a lost connection with its retry), whose controls stay live while it
+     *  sends. */
+    notices?: ReadonlyArray<Html | string>;
     /** The submit button's words. It prints primary, the card's default. */
     submit: string;
     /** The cancel button's words, before the submit. It closes through `closeAttributes`. */
@@ -40,9 +45,10 @@ export type FormViewConfig<Message> = Omit<ViewConfig<Message>, "body" | "closeA
     closeAttributes?: Attributes<Message>;
     /** The form's work is running (it sends): the submit button is busy, the close glyph and
      *  cancel are held without `closeAttributes`, and the body is natively disabled, so
-     *  nothing changes under the send and nothing sends twice. In a Dialog, hold its ways out
-     *  too (`Dialog.setCloseHeld`), and let go of both where the send fails. Enter in a field can submit before the fields are held,
-     *  so the update still ignores `onSubmit` while busy. */
+     *  nothing changes under the send and nothing sends twice. In a Dialog, pass the same state
+     *  as `isCloseHeld` to its update, so Escape and the veil are held too. Enter in a field
+     *  can submit before the fields are held, so the update still ignores `onSubmit` while
+     *  busy. */
     isBusy?: boolean;
     /** The form cannot be sent yet (nothing to send): the submit button is held as a Button
      *  is, and the fields and cancel stay live. Enter in a field can still submit, so the
@@ -55,7 +61,7 @@ export type FormViewConfig<Message> = Omit<ViewConfig<Message>, "body" | "closeA
  *  to the page: the form's update moves it here as it sends, with
  *  `Focus.Focus({ id: Card.submitId(id) })`. */
 export declare const submitId: (id: string) => string;
-/** A card that is a form, named by its title, so a form landmark: its body in one Fields
- *  group, then cancel and the primary submit button in the action bar. */
+/** A card that is a form, named by its title, so a form landmark: its notices, its body in
+ *  one Fields group, then cancel and the primary submit button in the action bar. */
 export declare const formView: <Message>(config: FormViewConfig<Message>, h: HtmlBuilder<Message>) => Html;
 //# sourceMappingURL=card.d.ts.map

package/dist/src/card/card.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"card.d.ts","sourceRoot":"","sources":["../../../src/card/card.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAQ9D,sDAAsD;AACtD,MAAM,MAAM,UAAU,CAAC,OAAO,IAAI,QAAQ,CAAC;IACzC,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,0FAA0F;IAC1F,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACnC;gDAC4C;IAC5C,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACtC,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACvC,uEAAuE;IACvE,IAAI,CAAC,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACpC;6DACyD;IACzD,mBAAmB,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;CAC3C,CAAC,CAAC;AAsDH,6FAA6F;AAC7F,eAAO,MAAM,IAAI,GAAI,OAAO,UAAU,UAAU,CAAC,OAAO,CAAC,KAAK,WAAW,CAAC,OAAO,CAAC,KAAG,IACd,CAAC;AAIxE;iEACiE;AACjE,MAAM,MAAM,cAAc,CAAC,OAAO,IAAI,IAAI,CACxC,UAAU,CAAC,OAAO,CAAC,EACnB,MAAM,GAAG,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAChD,GACC,QAAQ,CAAC;IACP,wEAAwE;IACxE,EAAE,EAAE,MAAM,CAAC;IACX;6CACyC;IACzC,IAAI,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACnC,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,yFAAyF;IACzF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;wEACoE;IACpE,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACtC;;;;6DAIyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;6DAEyD;IACzD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEL;;gDAEgD;AAChD,eAAO,MAAM,QAAQ,OAAQ,MAAM,KAAG,MAAwB,CAAC;AAE/D;0EAC0E;AAC1E,eAAO,MAAM,QAAQ,GAAI,OAAO,UACtB,cAAc,CAAC,OAAO,CAAC,KAC5B,WAAW,CAAC,OAAO,CAAC,KACtB,IAwDF,CAAC"}
+{"version":3,"file":"card.d.ts","sourceRoot":"","sources":["../../../src/card/card.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAQ9D,sDAAsD;AACtD,MAAM,MAAM,UAAU,CAAC,OAAO,IAAI,QAAQ,CAAC;IACzC,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,0FAA0F;IAC1F,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACnC;gDAC4C;IAC5C,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACtC,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACvC,uEAAuE;IACvE,IAAI,CAAC,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACpC;6DACyD;IACzD,mBAAmB,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;CAC3C,CAAC,CAAC;AAsDH,6FAA6F;AAC7F,eAAO,MAAM,IAAI,GAAI,OAAO,UAAU,UAAU,CAAC,OAAO,CAAC,KAAK,WAAW,CAAC,OAAO,CAAC,KAAG,IACd,CAAC;AAIxE;;yDAEyD;AACzD,MAAM,MAAM,cAAc,CAAC,OAAO,IAAI,IAAI,CACxC,UAAU,CAAC,OAAO,CAAC,EACnB,MAAM,GAAG,iBAAiB,GAAG,SAAS,CACvC,GACC,QAAQ,CAAC;IACP,wEAAwE;IACxE,EAAE,EAAE,MAAM,CAAC;IACX;6CACyC;IACzC,IAAI,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACnC;;iBAEa;IACb,OAAO,CAAC,EAAE,aAAa,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;IACvC,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,yFAAyF;IACzF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;wEACoE;IACpE,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IACtC;;;;;gBAKY;IACZ,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;6DAEyD;IACzD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEL;;gDAEgD;AAChD,eAAO,MAAM,QAAQ,OAAQ,MAAM,KAAG,MAAwB,CAAC;AAE/D;qFACqF;AACrF,eAAO,MAAM,QAAQ,GAAI,OAAO,UACtB,cAAc,CAAC,OAAO,CAAC,KAC5B,WAAW,CAAC,OAAO,CAAC,KACtB,IAyDF,CAAC"}

package/dist/src/card/card.js

@@ -33,10 +33,10 @@ export const view = (config, h) => __foldkitBrandViewResult((h.div([h.Class(clas
  *  to the page: the form's update moves it here as it sends, with
  *  `Focus.Focus({ id: Card.submitId(id) })`. */
 export const submitId = (id) => __foldkitBrandViewResult((`${id}-submit`), "@gjermundgaraba-designs/pixel-paper/src/card/card.js#submitId");
-/** A card that is a form, named by its title, so a form landmark: its body in one Fields
- *  group, then cancel and the primary submit button in the action bar. */
+/** A card that is a form, named by its title, so a form landmark: its notices, its body in
+ *  one Fields group, then cancel and the primary submit button in the action bar. */
 export const formView = (config, h) => {
-    const { id, title, submit, cancel, closeAttributes, isBusy = false, isSubmitDisabled = false, onSubmit, } = config;
+    const { id, title, submit, cancel, closeAttributes, notices = [], isBusy = false, isSubmitDisabled = false, onSubmit, } = config;
     const cancelButton = cancel === undefined
         ? []
         : [
@@ -62,7 +62,7 @@ export const formView = (config, h) => {
         h.OnSubmit(onSubmit),
     ], childrenView({
         ...config,
-        body: [Fields.view({ body: config.body, isBusy }, h)],
+        body: [...notices, Fields.view({ body: config.body, isBusy }, h)],
         isCloseHeld: isBusy,
         actions: [...cancelButton, submitButton],
     }, h))), "@gjermundgaraba-designs/pixel-paper/src/card/card.js#formView");

package/dist/src/commandPalette/commandPalette.d.ts

@@ -31,7 +31,6 @@ export declare const Model: Schema.Struct<{
             }>;
             readonly maybeFocusSelector: Schema.Option<Schema.String>;
         }>;
-        readonly isCloseHeld: Schema.Boolean;
     }>;
     readonly query: Schema.String;
     readonly maybeCursor: Schema.Option<Schema.String>;
@@ -127,7 +126,6 @@ export declare const update: (model: Model, message: Message) => Readonly<{
                 };
                 readonly maybeFocusSelector: Option.Option<string>;
             };
-            readonly isCloseHeld: boolean;
         };
         readonly query: string;
         readonly maybeCursor: Option.Option<string>;
@@ -291,7 +289,6 @@ export declare const subscriptions: <Prefix extends string>(keyPrefix: Prefix) =
                 };
                 readonly maybeFocusSelector: Option.Option<string>;
             };
-            readonly isCloseHeld: boolean;
         };
         readonly query: string;
         readonly maybeCursor: Option.Option<string>;
@@ -460,7 +457,6 @@ export declare const view: import("foldkit/submodel").View<{
             };
             readonly maybeFocusSelector: Option.Option<string>;
         };
-        readonly isCloseHeld: boolean;
     };
     readonly query: string;
     readonly maybeCursor: Option.Option<string>;

package/dist/src/commandPalette/commandPalette.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commandPalette.d.ts","sourceRoot":"","sources":["../../../src/commandPalette/commandPalette.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"commandPalette.d.ts","sourceRoot":"","sources":["../../../src/commandPalette/commandPalette.ts"],"names":[],"mappings":"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"}

package/dist/src/confirmDialog/confirmDialog.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
 import type { Html } from "foldkit/html";
 import * as Update from "foldkit/update";
+import * as Dialog from "../dialog/dialog.ts";
 /** Schema for a confirm dialog: the pixel-paper Dialog it opens in. */
 export declare const Model: Schema.Struct<{
     readonly dialog: Schema.Struct<{
@@ -16,7 +17,6 @@ export declare const Model: Schema.Struct<{
             }>;
             readonly maybeFocusSelector: Schema.Option<Schema.String>;
         }>;
-        readonly isCloseHeld: Schema.Boolean;
     }>;
 }>;
 export type Model = typeof Model.Type;
@@ -61,7 +61,7 @@ export type Message = typeof Message.Type;
 /** Union of OutMessages a confirm dialog reports. `Confirmed`: the reader pressed the action;
  *  the dialog stays open until the parent calls `close`. `Cancelled`: cancel, Escape or a click
  *  on the veil; the dialog has closed, and whether that also stops work already running is
- *  the parent's to decide. Never reported while its ways out are held (`setCloseHeld`). */
+ *  the parent's to decide. Never reported while its ways out are held (`Dialog.UpdateContext`). */
 export declare const OutMessage: import("foldkit/message").MessageUnion<{
     readonly Confirmed: {};
     readonly Cancelled: {};
@@ -73,8 +73,9 @@ export type InitConfig = Readonly<{
 }>;
 /** Creates a closed confirm dialog. */
 export declare const init: (config: InitConfig) => Model;
-/** Processes a confirm dialog Message and returns the next Model, Commands and OutMessage. */
-export declare const update: (model: Model, message: Message) => Readonly<{
+/** Processes a confirm dialog Message and returns the next Model, Commands and OutMessage.
+ *  While `context.isCloseHeld`, cancel, Escape and the veil change nothing. */
+export declare const update: (model: Model, message: Message, context?: Dialog.UpdateContext) => Readonly<{
     model: {
         readonly dialog: {
             readonly dialog: {
@@ -89,7 +90,6 @@ export declare const update: (model: Model, message: Message) => Readonly<{
                 };
                 readonly maybeFocusSelector: import("effect/Option").Option<string>;
             };
-            readonly isCloseHeld: boolean;
         };
     };
     commands?: Update.Commands<{
@@ -145,20 +145,13 @@ export declare const update: (model: Model, message: Message) => Readonly<{
 }>;
 /** Opens the confirm dialog: focus starts on the action, or on cancel when it is `isDanger`. */
 export declare const open: (model: Model) => Update.Return<Model, Message>;
-/** Closes the confirm dialog without reporting `Cancelled`, and lets go of a hold: call it
- *  once confirmed work has landed. */
+/** Closes the confirm dialog without reporting `Cancelled`: call it once confirmed work has
+ *  landed. */
 export declare const close: (model: Model) => Update.Return<Model, Message>;
-/** Holds cancel, Escape and the veil, or lets them go: while held the dialog stays open and
- *  reports no `Cancelled`, and cancel prints held (`aria-disabled`, in the keyboard). Hold it
- *  in the update that starts confirmed work whose failure must land here, and let go in the
- *  update where the work fails; `close` lets go once it lands. */
-export declare const setCloseHeld: (model: Model, isHeld: boolean) => Model;
 /** The confirm dialog's id, unique in the document. */
 export declare const id: (model: Model) => string;
 /** Whether the confirm dialog is open. */
 export declare const isOpen: (model: Model) => boolean;
-/** Whether its ways out are held (`setCloseHeld`). */
-export declare const isCloseHeld: (model: Model) => boolean;
 /** Per-render inputs passed to `view` through `h.submodel`'s `viewInputs`. */
 export type ViewInputs = Readonly<{
     /** The title bar: the action's name (`"Delete"`). */
@@ -178,8 +171,9 @@ export type ViewInputs = Readonly<{
     /** Destructive: the confirming button turns red and cancel becomes the default. */
     isDanger?: boolean;
     /** The confirmed work is running: the confirming button is held (its word stays, the
-     *  working cursor prints, a second press does nothing) and keeps focus. Cancel stays live
-     *  unless the dialog's ways out are held (`setCloseHeld`). */
+     *  working cursor prints, a second press does nothing) and keeps focus, and cancel is held
+     *  with it. Pair it with `isCloseHeld` in `update`'s context, from the same state, so
+     *  Escape and the veil change nothing either. */
     isBusy?: boolean;
     /** The action cannot run now (nothing is running; it is blocked): the confirming button is
      *  held, `aria-disabled` without the working cursor, and stays in the keyboard, so focus
@@ -198,9 +192,9 @@ export type ViewInputs = Readonly<{
  * arm-then-confirm button: red never rests on a button, and an armed button is easy to
  * double-click through.
  *
- * Work that takes a while stays in the dialog: set `isBusy` while it runs, `close` once it
- * has landed, and on failure keep it open with the error in `toDetailView`. Hold its ways
- * out with `setCloseHeld` too when the reader must stay to see how it ends.
+ * Work that takes a while stays in the dialog: set `isBusy` while it runs (and `isCloseHeld`
+ * in `update`'s context), `close` once it has landed, and on failure keep it open with the
+ * error in `toDetailView`.
  */
 export declare const view: import("foldkit/submodel").View<{
     readonly dialog: {
@@ -216,7 +210,6 @@ export declare const view: import("foldkit/submodel").View<{
             };
             readonly maybeFocusSelector: import("effect/Option").Option<string>;
         };
-        readonly isCloseHeld: boolean;
     };
 }, {
     readonly _tag: "ClickedCancel";
@@ -280,8 +273,9 @@ export declare const view: import("foldkit/submodel").View<{
     /** Destructive: the confirming button turns red and cancel becomes the default. */
     isDanger?: boolean;
     /** The confirmed work is running: the confirming button is held (its word stays, the
-     *  working cursor prints, a second press does nothing) and keeps focus. Cancel stays live
-     *  unless the dialog's ways out are held (`setCloseHeld`). */
+     *  working cursor prints, a second press does nothing) and keeps focus, and cancel is held
+     *  with it. Pair it with `isCloseHeld` in `update`'s context, from the same state, so
+     *  Escape and the veil change nothing either. */
     isBusy?: boolean;
     /** The action cannot run now (nothing is running; it is blocked): the confirming button is
      *  held, `aria-disabled` without the working cursor, and stays in the keyboard, so focus

package/dist/src/confirmDialog/confirmDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"confirmDialog.d.ts","sourceRoot":"","sources":["../../../src/confirmDialog/confirmDialog.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"confirmDialog.d.ts","sourceRoot":"","sources":["../../../src/confirmDialog/confirmDialog.ts"],"names":[],"mappings":"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"}

package/dist/src/confirmDialog/confirmDialog.js

@@ -25,7 +25,7 @@ export const Message = defineMessageUnion({
 /** Union of OutMessages a confirm dialog reports. `Confirmed`: the reader pressed the action;
  *  the dialog stays open until the parent calls `close`. `Cancelled`: cancel, Escape or a click
  *  on the veil; the dialog has closed, and whether that also stops work already running is
- *  the parent's to decide. Never reported while its ways out are held (`setCloseHeld`). */
+ *  the parent's to decide. Never reported while its ways out are held (`Dialog.UpdateContext`). */
 export const OutMessage = defineMessageUnion({
     Confirmed: {},
     Cancelled: {},
@@ -44,32 +44,27 @@ const dialogFold = foldDialog(Dialog, {
     toParentMessage: (message) => __foldkitBrandViewResult((Message.GotDialogMessage({ message })), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#toParentMessage"),
     toParentOutMessage: toCancelled,
 });
-/** Processes a confirm dialog Message and returns the next Model, Commands and OutMessage. */
-export const update = (model, message) => __foldkitBrandViewResult((Message.match(message, {
-    GotDialogMessage: ({ message: dialogMessage }) => __foldkitBrandViewResult((dialogFold.update(model, dialogMessage)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#GotDialogMessage"),
+const FREE = { isCloseHeld: false };
+/** Processes a confirm dialog Message and returns the next Model, Commands and OutMessage.
+ *  While `context.isCloseHeld`, cancel, Escape and the veil change nothing. */
+export const update = (model, message, context = FREE) => __foldkitBrandViewResult((Message.match(message, {
+    GotDialogMessage: ({ message: dialogMessage }) => __foldkitBrandViewResult((dialogFold.updateWith(context)(model, dialogMessage)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#GotDialogMessage"),
     ClickedConfirm: () => (__foldkitBrandViewResult(({ model, outMessage: OutMessage.Confirmed() }), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#ClickedConfirm")),
-    ClickedCancel: () => __foldkitBrandViewResult((Dialog.isCloseHeld(model.dialog)
+    ClickedCancel: () => __foldkitBrandViewResult((context.isCloseHeld
         ? { model }
         : pipe(dialogFold.close(model), Update.withOutMessage(OutMessage.Cancelled()))), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#ClickedCancel"),
 })), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#update");
 /** Opens the confirm dialog: focus starts on the action, or on cancel when it is `isDanger`. */
 export const open = (model) => __foldkitBrandViewResult((dialogFold.open(model)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#open");
-/** Closes the confirm dialog without reporting `Cancelled`, and lets go of a hold: call it
- *  once confirmed work has landed. */
+/** Closes the confirm dialog without reporting `Cancelled`: call it once confirmed work has
+ *  landed. */
 export const close = (model) => __foldkitBrandViewResult((dialogFold.close(model)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#close");
-/** Holds cancel, Escape and the veil, or lets them go: while held the dialog stays open and
- *  reports no `Cancelled`, and cancel prints held (`aria-disabled`, in the keyboard). Hold it
- *  in the update that starts confirmed work whose failure must land here, and let go in the
- *  update where the work fails; `close` lets go once it lands. */
-export const setCloseHeld = (model, isHeld) => __foldkitBrandViewResult((modifyFields(model, { dialog: (dialog) => __foldkitBrandViewResult((Dialog.setCloseHeld(dialog, isHeld)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#dialog~2") })), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#setCloseHeld");
 // ACCESSORS
 /** The confirm dialog's id, unique in the document. */
 export const id = (model) => __foldkitBrandViewResult((Dialog.id(model.dialog)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#id");
 /** Whether the confirm dialog is open. */
 export const isOpen = (model) => __foldkitBrandViewResult((Dialog.isOpen(model.dialog)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#isOpen");
-/** Whether its ways out are held (`setCloseHeld`). */
-export const isCloseHeld = (model) => __foldkitBrandViewResult((Dialog.isCloseHeld(model.dialog)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#isCloseHeld");
-const cardView = (model, viewInputs, render, h) => {
+const cardView = (viewInputs, render, h) => {
     const { isDanger = false, isBusy = false, isDisabled = false, toDetailView } = viewInputs;
     const commit = Button.view({
         label: viewInputs.label,
@@ -83,7 +78,7 @@ const cardView = (model, viewInputs, render, h) => {
     const cancel = Button.view({
         label: "cancel",
         isDefault: isDanger,
-        isDisabled: Dialog.isCloseHeld(model.dialog),
+        isDisabled: isBusy,
         onClick: Message.ClickedCancel(),
         attributes: isDanger ? render.initialFocus : [],
     }, h);
@@ -113,9 +108,9 @@ const cardView = (model, viewInputs, render, h) => {
  * arm-then-confirm button: red never rests on a button, and an armed button is easy to
  * double-click through.
  *
- * Work that takes a while stays in the dialog: set `isBusy` while it runs, `close` once it
- * has landed, and on failure keep it open with the error in `toDetailView`. Hold its ways
- * out with `setCloseHeld` too when the reader must stay to see how it ends.
+ * Work that takes a while stays in the dialog: set `isBusy` while it runs (and `isCloseHeld`
+ * in `update`'s context), `close` once it has landed, and on failure keep it open with the
+ * error in `toDetailView`.
  */
 export const view = defineView((model, viewInputs, h) => __foldkitBrandViewResult((h.submodel({
     slotId: id(model),
@@ -125,7 +120,7 @@ export const view = defineView((model, viewInputs, h) => __foldkitBrandViewResul
         isAlert: viewInputs.isDanger ?? false,
         hasDescription: true,
         toLiveRegionView: viewInputs.toLiveRegionView,
-        toView: (render) => __foldkitBrandViewResult((cardView(model, viewInputs, render, h)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#toView"),
+        toView: (render) => __foldkitBrandViewResult((cardView(viewInputs, render, h)), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#toView"),
     },
     toParentMessage: (message) => __foldkitBrandViewResult((Message.GotDialogMessage({ message })), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#toParentMessage~2"),
 })), "@gjermundgaraba-designs/pixel-paper/src/confirmDialog/confirmDialog.js#anonymous"));

package/dist/src/confirmDialog/index.d.ts

@@ -1,3 +1,3 @@
-export { Message, Model, OutMessage, close, id, init, isCloseHeld, isOpen, open, setCloseHeld, update, view, } from "./confirmDialog.ts";
+export { Message, Model, OutMessage, close, id, init, isOpen, open, update, view, } from "./confirmDialog.ts";
 export type { InitConfig, ViewInputs } from "./confirmDialog.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/confirmDialog/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/confirmDialog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,KAAK,EACL,UAAU,EACV,KAAK,EACL,EAAE,EACF,IAAI,EACJ,WAAW,EACX,MAAM,EACN,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,IAAI,GACL,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/confirmDialog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,KAAK,EACL,UAAU,EACV,KAAK,EACL,EAAE,EACF,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,MAAM,EACN,IAAI,GACL,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/src/confirmDialog/index.js

@@ -1 +1 @@
-export { Message, Model, OutMessage, close, id, init, isCloseHeld, isOpen, open, setCloseHeld, update, view, } from "./confirmDialog.js";
+export { Message, Model, OutMessage, close, id, init, isOpen, open, update, view, } from "./confirmDialog.js";

package/dist/src/dialog/dialog.d.ts

@@ -2,8 +2,7 @@ import { Option, Schema } from "effect";
 import { type ChildAttribute, type Html } from "foldkit/html";
 import * as Mount from "foldkit/mount";
 import type * as Update from "foldkit/update";
-/** Schema for a pixel-paper dialog: the `@foldkit/ui` Dialog it is built on, and whether its
- *  ways out are held (`setCloseHeld`). */
+/** Schema for a pixel-paper dialog: the `@foldkit/ui` Dialog it is built on. */
 export declare const Model: Schema.Struct<{
     readonly dialog: Schema.Struct<{
         readonly id: Schema.String;
@@ -17,7 +16,6 @@ export declare const Model: Schema.Struct<{
         }>;
         readonly maybeFocusSelector: Schema.Option<Schema.String>;
     }>;
-    readonly isCloseHeld: Schema.Boolean;
 }>;
 export type Model = typeof Model.Type;
 /** Which way h, l and the side arrows move focus in a dialog's action bar. */
@@ -75,10 +73,17 @@ export declare const init: (config: InitConfig) => Model;
 export declare const id: (model: Model) => string;
 /** Whether the dialog is open. */
 export declare const isOpen: (model: Model) => boolean;
-/** Whether the dialog's ways out are held (`setCloseHeld`). */
-export declare const isCloseHeld: (model: Model) => boolean;
+/** What a dialog's update reads from its parent as a Message arrives. */
+export type UpdateContext = Readonly<{
+    /** The reader may not walk away from the work running now (a save whose failure must land
+     *  in this dialog): Escape, a press on the veil and a control given the `closeButton` group
+     *  change nothing and report no `Closed`. Read it from the parent's own state as the
+     *  Message arrives (`isSaving(model)`), so it holds exactly while the work runs, however
+     *  soon after the start a key comes. */
+    isCloseHeld: boolean;
+}>;
 /** Processes a dialog Message and returns the next Model, Commands and OutMessage. */
-export declare const update: (model: Model, message: Message) => Readonly<{
+export declare const update: (model: Model, message: Message, context?: UpdateContext) => Readonly<{
     model: {
         readonly dialog: {
             readonly id: string;
@@ -92,7 +97,6 @@ export declare const update: (model: Model, message: Message) => Readonly<{
             };
             readonly maybeFocusSelector: Option.Option<string>;
         };
-        readonly isCloseHeld: boolean;
     };
     commands?: Update.Commands<{
         readonly _tag: "GotDialogMessage";
@@ -139,15 +143,8 @@ export declare const update: (model: Model, message: Message) => Readonly<{
 /** Opens the dialog: focus moves to the element given the `initialFocus` group, else to the
  *  first control, and returns to where it was when the dialog closes. */
 export declare const open: (model: Model) => Update.Return<Model, Message>;
-/** Closes the dialog without reporting `Closed`, and lets go of a hold. */
+/** Closes the dialog without reporting `Closed`. */
 export declare const close: (model: Model) => Update.Return<Model, Message>;
-/** Holds the dialog's ways out, or lets them go: while held, Escape, a press on the veil and
- *  a control given the `closeButton` group leave it open and report no `Closed`, so the
- *  result of work the reader may not walk away from (a save whose failure must land here)
- *  lands in it. Hold it in the update that starts the work, and let go in the update where
- *  the work fails, or the reader is shut in with the failure; `close` lets go once it lands.
- *  Hold the card's own close controls too (`Card.formView`'s `isBusy`). */
-export declare const setCloseHeld: (model: Model, isHeld: boolean) => Model;
 /** Moves focus for one keydown in an action bar, and says which way it moved. It moves only
  *  when the key's target is one of the bar's own actions and there is an action that way:
  *  a key typed in a field, a menu's item or a nested dialog inside the bar, a key an IME is
@@ -235,7 +232,6 @@ export declare const view: import("foldkit/submodel").View<{
         };
         readonly maybeFocusSelector: Option.Option<string>;
     };
-    readonly isCloseHeld: boolean;
 }, {
     readonly _tag: "GotDialogMessage";
     readonly message: {

package/dist/src/dialog/dialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dialog.d.ts","sourceRoot":"","sources":["../../../src/dialog/dialog.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dialog.d.ts","sourceRoot":"","sources":["../../../src/dialog/dialog.ts"],"names":[],"mappings":"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"}

package/dist/src/dialog/dialog.js

@@ -10,11 +10,9 @@ import { defineView } from "foldkit/submodel";
 import { isPlain } from "../keys/keys.js";
 import { foldDialog } from "./fold.js";
 // MODEL
-/** Schema for a pixel-paper dialog: the `@foldkit/ui` Dialog it is built on, and whether its
- *  ways out are held (`setCloseHeld`). */
+/** Schema for a pixel-paper dialog: the `@foldkit/ui` Dialog it is built on. */
 export const Model = Schema.Struct({
     dialog: UiDialog.Model,
-    isCloseHeld: Schema.Boolean,
 });
 /** Which way h, l and the side arrows move focus in a dialog's action bar. */
 const ActionDirection = Schema.Literals(["Previous", "Next"]);
@@ -36,15 +34,12 @@ export const OutMessage = defineMessageUnion({
 /** Creates a closed dialog. */
 export const init = (config) => (__foldkitBrandViewResult(({
     dialog: UiDialog.init({ id: config.id }),
-    isCloseHeld: false,
 }), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#init"));
 // ACCESSORS
 /** The dialog's id, unique in the document. */
 export const id = (model) => __foldkitBrandViewResult((model.dialog.id), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#id");
 /** Whether the dialog is open. */
 export const isOpen = (model) => __foldkitBrandViewResult((model.dialog.isOpen), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#isOpen");
-/** Whether the dialog's ways out are held (`setCloseHeld`). */
-export const isCloseHeld = (model) => __foldkitBrandViewResult((model.isCloseHeld), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#isCloseHeld");
 // UPDATE
 const toOutMessage = UiDialog.OutMessage.match({
     Opened: () => __foldkitBrandViewResult((undefined), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#Opened"),
@@ -56,27 +51,21 @@ const dialogFold = foldDialog(UiDialog, {
     toParentMessage: (message) => __foldkitBrandViewResult((Message.GotDialogMessage({ message })), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#toParentMessage"),
     toParentOutMessage: toOutMessage,
 });
+const FREE = { isCloseHeld: false };
 // NOTE: @foldkit/ui gap: Dialog has no way to hold a close. Escape, a press on the veil and a
 // control given the `closeButton` group all send `RequestedClose`, so a held dialog reads it
 // by its tag and leaves it out.
-const isHeldClose = (model, message) => __foldkitBrandViewResult((model.isCloseHeld && message._tag === "RequestedClose"), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#isHeldClose");
+const isHeldClose = (context, message) => __foldkitBrandViewResult((context.isCloseHeld && message._tag === "RequestedClose"), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#isHeldClose");
 /** Processes a dialog Message and returns the next Model, Commands and OutMessage. */
-export const update = (model, message) => __foldkitBrandViewResult((Message.match(message, {
-    GotDialogMessage: ({ message: dialogMessage }) => __foldkitBrandViewResult((isHeldClose(model, dialogMessage) ? { model } : dialogFold.update(model, dialogMessage)), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#GotDialogMessage"),
+export const update = (model, message, context = FREE) => __foldkitBrandViewResult((Message.match(message, {
+    GotDialogMessage: ({ message: dialogMessage }) => __foldkitBrandViewResult((isHeldClose(context, dialogMessage) ? { model } : dialogFold.update(model, dialogMessage)), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#GotDialogMessage"),
     PressedActionKey: () => (__foldkitBrandViewResult(({ model }), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#PressedActionKey")),
 })), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#update");
 /** Opens the dialog: focus moves to the element given the `initialFocus` group, else to the
  *  first control, and returns to where it was when the dialog closes. */
 export const open = (model) => __foldkitBrandViewResult((dialogFold.open(model)), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#open");
-/** Closes the dialog without reporting `Closed`, and lets go of a hold. */
-export const close = (model) => __foldkitBrandViewResult((dialogFold.close(modifyFields(model, { isCloseHeld: () => __foldkitBrandViewResult((false), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#isCloseHeld~2") }))), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#close");
-/** Holds the dialog's ways out, or lets them go: while held, Escape, a press on the veil and
- *  a control given the `closeButton` group leave it open and report no `Closed`, so the
- *  result of work the reader may not walk away from (a save whose failure must land here)
- *  lands in it. Hold it in the update that starts the work, and let go in the update where
- *  the work fails, or the reader is shut in with the failure; `close` lets go once it lands.
- *  Hold the card's own close controls too (`Card.formView`'s `isBusy`). */
-export const setCloseHeld = (model, isHeld) => __foldkitBrandViewResult((modifyFields(model, { isCloseHeld: () => __foldkitBrandViewResult((isHeld), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#isCloseHeld~3") })), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#setCloseHeld");
+/** Closes the dialog without reporting `Closed`. */
+export const close = (model) => __foldkitBrandViewResult((dialogFold.close(model)), "@gjermundgaraba-designs/pixel-paper/src/dialog/dialog.js#close");
 // ACTION BAR KEYS
 const ACTION_BAR_ATTRIBUTE = "data-pixel-paper-action-bar";
 const ACTION_SELECTOR = "button:not(:disabled), a[href]";

package/dist/src/dialog/fold.d.ts

@@ -1,9 +1,10 @@
 import * as Update from "foldkit/update";
+import type { UpdateContext } from "./dialog.ts";
 type ChildReturn<ChildModel, ChildMessage, ChildOutMessage> = Update.ReturnWithOutMessage<ChildModel, ChildMessage, ChildOutMessage>;
 /** A dialog a parent holds: its update, and the steps that open and close it (`@foldkit/ui`'s
  *  Dialog, or pixel-paper's). */
 type DialogChild<ChildModel, ChildMessage, ChildOutMessage> = Readonly<{
-    update: (model: ChildModel, message: ChildMessage) => ChildReturn<ChildModel, ChildMessage, ChildOutMessage>;
+    update: (model: ChildModel, message: ChildMessage, context: UpdateContext) => ChildReturn<ChildModel, ChildMessage, ChildOutMessage>;
     open: (model: ChildModel) => ChildReturn<ChildModel, ChildMessage, ChildOutMessage>;
     close: (model: ChildModel) => ChildReturn<ChildModel, ChildMessage, ChildOutMessage>;
 }>;
@@ -16,10 +17,17 @@ type DialogFoldConfig<ParentModel, ParentMessage, ParentOutMessage, ChildModel,
      *  veil, a close button). Without it the dialog's OutMessages report nothing: a parent
      *  that reads `isOpen` when it needs to. */
     toParentOutMessage?: (outMessage: ChildOutMessage) => ParentOutMessage | undefined;
+    /** Whether the dialog's ways out are held, read from the parent's own state as each
+     *  Message arrives (`(model) => model.isSaving`). Free when not given. See
+     *  `Dialog.UpdateContext`. */
+    isCloseHeld?: (model: ParentModel) => boolean;
 }>;
 /** The dialog folded into its parent: a dialog Message, and opening and closing it. */
 type DialogFold<ParentModel, ParentMessage, ParentOutMessage, ChildMessage> = Readonly<{
     update: (model: ParentModel, message: ChildMessage) => Update.ReturnWithOutMessage<ParentModel, ParentMessage, ParentOutMessage>;
+    /** The update a parent that is itself a dialog (ConfirmDialog) runs with the hold its own
+     *  parent gave it. */
+    updateWith: (context: UpdateContext) => (model: ParentModel, message: ChildMessage) => Update.ReturnWithOutMessage<ParentModel, ParentMessage, ParentOutMessage>;
     open: (model: ParentModel) => Update.Return<ParentModel, ParentMessage>;
     close: (model: ParentModel) => Update.Return<ParentModel, ParentMessage>;
 }>;

package/dist/src/dialog/fold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../../src/dialog/fold.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AAIzC,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,IAAI,MAAM,CAAC,oBAAoB,CACvF,UAAU,EACV,YAAY,EACZ,eAAe,CAChB,CAAC;AAEF;iCACiC;AACjC,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,IAAI,QAAQ,CAAC;IACrE,MAAM,EAAE,CACN,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,KAClB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;IAC5D,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;IACpF,KAAK,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;CACtF,CAAC,CAAC;AAEH,gGAAgG;AAChG,KAAK,gBAAgB,CACnB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,eAAe,IACb,QAAQ,CAAC;IACX,IAAI,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,UAAU,CAAC;IACzC,KAAK,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,KAAK,WAAW,CAAC;IACnE,eAAe,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,aAAa,CAAC;IAC1D;;gDAE4C;IAC5C,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,gBAAgB,GAAG,SAAS,CAAC;CACpF,CAAC,CAAC;AAEH,uFAAuF;AACvF,KAAK,UAAU,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,IAAI,QAAQ,CAAC;IACrF,MAAM,EAAE,CACN,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,YAAY,KAClB,MAAM,CAAC,oBAAoB,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAC/E,IAAI,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IACxE,KAAK,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;CAC1E,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;uFAsBuF;AACvF,eAAO,MAAM,UAAU,GACrB,WAAW,EACX,aAAa,EACb,UAAU,EACV,YAAY,EACZ,eAAe,EACf,gBAAgB,GAAG,KAAK,SAEjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,UACrD,gBAAgB,CACtB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,eAAe,CAChB,KACA,UAAU,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,CAqBvE,CAAC"}
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../../src/dialog/fold.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,IAAI,MAAM,CAAC,oBAAoB,CACvF,UAAU,EACV,YAAY,EACZ,eAAe,CAChB,CAAC;AAEF;iCACiC;AACjC,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,IAAI,QAAQ,CAAC;IACrE,MAAM,EAAE,CACN,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,aAAa,KACnB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;IAC5D,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;IACpF,KAAK,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;CACtF,CAAC,CAAC;AAEH,gGAAgG;AAChG,KAAK,gBAAgB,CACnB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,eAAe,IACb,QAAQ,CAAC;IACX,IAAI,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,UAAU,CAAC;IACzC,KAAK,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,KAAK,WAAW,CAAC;IACnE,eAAe,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,aAAa,CAAC;IAC1D;;gDAE4C;IAC5C,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,gBAAgB,GAAG,SAAS,CAAC;IACnF;;kCAE8B;IAC9B,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC;CAC/C,CAAC,CAAC;AAEH,uFAAuF;AACvF,KAAK,UAAU,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,IAAI,QAAQ,CAAC;IACrF,MAAM,EAAE,CACN,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,YAAY,KAClB,MAAM,CAAC,oBAAoB,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAC/E;0BACsB;IACtB,UAAU,EAAE,CACV,OAAO,EAAE,aAAa,KACnB,CACH,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,YAAY,KAClB,MAAM,CAAC,oBAAoB,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAC/E,IAAI,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IACxE,KAAK,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;CAC1E,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;uFAsBuF;AACvF,eAAO,MAAM,UAAU,GACrB,WAAW,EACX,aAAa,EACb,UAAU,EACV,YAAY,EACZ,eAAe,EACf,gBAAgB,GAAG,KAAK,SAEjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,eAAe,CAAC,UACrD,gBAAgB,CACtB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,eAAe,CAChB,KACA,UAAU,CAAC,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,CAyBvE,CAAC"}

package/dist/src/dialog/fold.js

@@ -34,12 +34,16 @@ export const foldDialog = (child, config) => {
     // `RequestedOpen`, which reports `Opened`), and so can its update, so each fold needs a
     // step for an OutMessage. This one keeps the parent's Model: a step reports nothing.
     const foldOutMessage = () => __foldkitBrandViewResult(((model) => (__foldkitBrandViewResult(({ model }), "@gjermundgaraba-designs/pixel-paper/src/dialog/fold.js#anonymous"))), "@gjermundgaraba-designs/pixel-paper/src/dialog/fold.js#foldOutMessage");
-    const { toParentOutMessage } = config;
-    const update = toParentOutMessage === undefined
-        ? Update.foldChild({ update: child.update, ...lift, foldOutMessage })
-        : Update.foldChild({ update: child.update, ...lift, toParentOutMessage });
+    const { toParentOutMessage, isCloseHeld = () => __foldkitBrandViewResult((false), "@gjermundgaraba-designs/pixel-paper/src/dialog/fold.js#anonymous~2") } = config;
+    const updateWith = (context) => {
+        const childUpdate = (model, message) => __foldkitBrandViewResult((child.update(model, message, context)), "@gjermundgaraba-designs/pixel-paper/src/dialog/fold.js#childUpdate");
+        return __foldkitBrandViewResult((toParentOutMessage === undefined
+            ? Update.foldChild({ update: childUpdate, ...lift, foldOutMessage })
+            : Update.foldChild({ update: childUpdate, ...lift, toParentOutMessage })), "@gjermundgaraba-designs/pixel-paper/src/dialog/fold.js#updateWith");
+    };
     return __foldkitBrandViewResult(({
-        update,
+        update: (model, message) => __foldkitBrandViewResult((updateWith({ isCloseHeld: isCloseHeld(model) })(model, message)), "@gjermundgaraba-designs/pixel-paper/src/dialog/fold.js#update"),
+        updateWith,
         open: Update.foldChildStep({ update: child.open, ...lift, foldOutMessage }),
         close: Update.foldChildStep({ update: child.close, ...lift, foldOutMessage }),
     }), "@gjermundgaraba-designs/pixel-paper/src/dialog/fold.js#foldDialog");

package/dist/src/dialog/index.d.ts

@@ -1,4 +1,4 @@
-export { BindActionKeys, Message, Model, OutMessage, close, id, init, isCloseHeld, isOpen, open, sceneMounts, setCloseHeld, update, view, } from "./dialog.ts";
-export type { InitConfig, Placement, RenderInfo, ViewInputs } from "./dialog.ts";
+export { BindActionKeys, Message, Model, OutMessage, close, id, init, isOpen, open, sceneMounts, update, view, } from "./dialog.ts";
+export type { InitConfig, Placement, RenderInfo, UpdateContext, ViewInputs } from "./dialog.ts";
 export { foldDialog } from "./fold.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/dialog/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,OAAO,EACP,KAAK,EACL,UAAU,EACV,KAAK,EACL,EAAE,EACF,IAAI,EACJ,WAAW,EACX,MAAM,EACN,IAAI,EACJ,WAAW,EACX,YAAY,EACZ,MAAM,EACN,IAAI,GACL,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,OAAO,EACP,KAAK,EACL,UAAU,EACV,KAAK,EACL,EAAE,EACF,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,WAAW,EACX,MAAM,EACN,IAAI,GACL,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAChG,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/dist/src/dialog/index.js

@@ -1,2 +1,2 @@
-export { BindActionKeys, Message, Model, OutMessage, close, id, init, isCloseHeld, isOpen, open, sceneMounts, setCloseHeld, update, view, } from "./dialog.js";
+export { BindActionKeys, Message, Model, OutMessage, close, id, init, isOpen, open, sceneMounts, update, view, } from "./dialog.js";
 export { foldDialog } from "./fold.js";

package/dist/src/keyHelp/keyHelp.d.ts

@@ -20,7 +20,6 @@ export declare const Model: Schema.Struct<{
             }>;
             readonly maybeFocusSelector: Schema.Option<Schema.String>;
         }>;
-        readonly isCloseHeld: Schema.Boolean;
     }>;
     readonly query: Schema.String;
 }>;
@@ -106,7 +105,6 @@ export declare const update: (model: Model, message: Message) => Readonly<{
                 };
                 readonly maybeFocusSelector: import("effect/Option").Option<string>;
             };
-            readonly isCloseHeld: boolean;
         };
         readonly query: string;
     };
@@ -184,7 +182,6 @@ export declare const subscriptions: {
                 };
                 readonly maybeFocusSelector: import("effect/Option").Option<string>;
             };
-            readonly isCloseHeld: boolean;
         };
         readonly query: string;
     }, {
@@ -271,7 +268,6 @@ export declare const view: import("foldkit/submodel").View<{
             };
             readonly maybeFocusSelector: import("effect/Option").Option<string>;
         };
-        readonly isCloseHeld: boolean;
     };
     readonly query: string;
 }, {

package/dist/src/keyHelp/keyHelp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyHelp.d.ts","sourceRoot":"","sources":["../../../src/keyHelp/keyHelp.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"keyHelp.d.ts","sourceRoot":"","sources":["../../../src/keyHelp/keyHelp.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjermundgaraba-designs/pixel-paper",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/card/card.ts

@@ -90,10 +90,11 @@ export const view = <Message>(config: ViewConfig<Message>, h: HtmlBuilder<Messag
 // FORM
 
 /** Configuration for rendering a form card with `formView`: a card's, but for its body, its
- *  close attributes and its action bar, which the form fills. */
+ *  close attributes and its actions, which the form fills. `lead` stays the card's: what
+ *  goes before the push, such as a form's own delete. */
 export type FormViewConfig<Message> = Omit<
   ViewConfig<Message>,
-  "body" | "closeAttributes" | "actions" | "lead"
+  "body" | "closeAttributes" | "actions"
 > &
   Readonly<{
     /** Unique in the document: the submit button's id is `submitId(id)`. */
@@ -101,6 +102,10 @@ export type FormViewConfig<Message> = Omit<
     /** The form's content, fields and all, in one Fields group that `isBusy` holds. A link in
      *  it (an ErrorSummary's) stays live. */
     body: ReadonlyArray<Html | string>;
+    /** Above the fields, outside the group `isBusy` holds: what the page says about the form
+     *  while it is open (a lost connection with its retry), whose controls stay live while it
+     *  sends. */
+    notices?: ReadonlyArray<Html | string>;
     /** The submit button's words. It prints primary, the card's default. */
     submit: string;
     /** The cancel button's words, before the submit. It closes through `closeAttributes`. */
@@ -110,9 +115,10 @@ export type FormViewConfig<Message> = Omit<
     closeAttributes?: Attributes<Message>;
     /** The form's work is running (it sends): the submit button is busy, the close glyph and
      *  cancel are held without `closeAttributes`, and the body is natively disabled, so
-     *  nothing changes under the send and nothing sends twice. In a Dialog, hold its ways out
-     *  too (`Dialog.setCloseHeld`), and let go of both where the send fails. Enter in a field can submit before the fields are held,
-     *  so the update still ignores `onSubmit` while busy. */
+     *  nothing changes under the send and nothing sends twice. In a Dialog, pass the same state
+     *  as `isCloseHeld` to its update, so Escape and the veil are held too. Enter in a field
+     *  can submit before the fields are held, so the update still ignores `onSubmit` while
+     *  busy. */
     isBusy?: boolean;
     /** The form cannot be sent yet (nothing to send): the submit button is held as a Button
      *  is, and the fields and cancel stay live. Enter in a field can still submit, so the
@@ -127,8 +133,8 @@ export type FormViewConfig<Message> = Omit<
  *  `Focus.Focus({ id: Card.submitId(id) })`. */
 export const submitId = (id: string): string => `${id}-submit`;
 
-/** A card that is a form, named by its title, so a form landmark: its body in one Fields
- *  group, then cancel and the primary submit button in the action bar. */
+/** A card that is a form, named by its title, so a form landmark: its notices, its body in
+ *  one Fields group, then cancel and the primary submit button in the action bar. */
 export const formView = <Message>(
   config: FormViewConfig<Message>,
   h: HtmlBuilder<Message>,
@@ -139,6 +145,7 @@ export const formView = <Message>(
     submit,
     cancel,
     closeAttributes,
+    notices = [],
     isBusy = false,
     isSubmitDisabled = false,
     onSubmit,
@@ -181,7 +188,7 @@ export const formView = <Message>(
     childrenView(
       {
         ...config,
-        body: [Fields.view({ body: config.body, isBusy }, h)],
+        body: [...notices, Fields.view({ body: config.body, isBusy }, h)],
         isCloseHeld: isBusy,
         actions: [...cancelButton, submitButton],
       },

package/src/confirmDialog/confirmDialog.ts

@@ -34,7 +34,7 @@ export type Message = typeof Message.Type;
 /** Union of OutMessages a confirm dialog reports. `Confirmed`: the reader pressed the action;
  *  the dialog stays open until the parent calls `close`. `Cancelled`: cancel, Escape or a click
  *  on the veil; the dialog has closed, and whether that also stops work already running is
- *  the parent's to decide. Never reported while its ways out are held (`setCloseHeld`). */
+ *  the parent's to decide. Never reported while its ways out are held (`Dialog.UpdateContext`). */
 export const OutMessage = defineMessageUnion({
   Confirmed: {},
   Cancelled: {},
@@ -65,13 +65,17 @@ const dialogFold = foldDialog(Dialog, {
   toParentOutMessage: toCancelled,
 });
 
-/** Processes a confirm dialog Message and returns the next Model, Commands and OutMessage. */
-export const update = (model: Model, message: Message) =>
+const FREE: Dialog.UpdateContext = { isCloseHeld: false };
+
+/** Processes a confirm dialog Message and returns the next Model, Commands and OutMessage.
+ *  While `context.isCloseHeld`, cancel, Escape and the veil change nothing. */
+export const update = (model: Model, message: Message, context: Dialog.UpdateContext = FREE) =>
   Message.match<Update.ReturnWithOutMessage<Model, Message, OutMessage>>(message, {
-    GotDialogMessage: ({ message: dialogMessage }) => dialogFold.update(model, dialogMessage),
+    GotDialogMessage: ({ message: dialogMessage }) =>
+      dialogFold.updateWith(context)(model, dialogMessage),
     ClickedConfirm: () => ({ model, outMessage: OutMessage.Confirmed() }),
     ClickedCancel: () =>
-      Dialog.isCloseHeld(model.dialog)
+      context.isCloseHeld
         ? { model }
         : pipe(dialogFold.close(model), Update.withOutMessage(OutMessage.Cancelled())),
   });
@@ -79,17 +83,10 @@ export const update = (model: Model, message: Message) =>
 /** Opens the confirm dialog: focus starts on the action, or on cancel when it is `isDanger`. */
 export const open = (model: Model): Update.Return<Model, Message> => dialogFold.open(model);
 
-/** Closes the confirm dialog without reporting `Cancelled`, and lets go of a hold: call it
- *  once confirmed work has landed. */
+/** Closes the confirm dialog without reporting `Cancelled`: call it once confirmed work has
+ *  landed. */
 export const close = (model: Model): Update.Return<Model, Message> => dialogFold.close(model);
 
-/** Holds cancel, Escape and the veil, or lets them go: while held the dialog stays open and
- *  reports no `Cancelled`, and cancel prints held (`aria-disabled`, in the keyboard). Hold it
- *  in the update that starts confirmed work whose failure must land here, and let go in the
- *  update where the work fails; `close` lets go once it lands. */
-export const setCloseHeld = (model: Model, isHeld: boolean): Model =>
-  modifyFields(model, { dialog: (dialog) => Dialog.setCloseHeld(dialog, isHeld) });
-
 // ACCESSORS
 
 /** The confirm dialog's id, unique in the document. */
@@ -98,9 +95,6 @@ export const id = (model: Model): string => Dialog.id(model.dialog);
 /** Whether the confirm dialog is open. */
 export const isOpen = (model: Model): boolean => Dialog.isOpen(model.dialog);
 
-/** Whether its ways out are held (`setCloseHeld`). */
-export const isCloseHeld = (model: Model): boolean => Dialog.isCloseHeld(model.dialog);
-
 // VIEW
 
 /** Per-render inputs passed to `view` through `h.submodel`'s `viewInputs`. */
@@ -122,8 +116,9 @@ export type ViewInputs = Readonly<{
   /** Destructive: the confirming button turns red and cancel becomes the default. */
   isDanger?: boolean;
   /** The confirmed work is running: the confirming button is held (its word stays, the
-   *  working cursor prints, a second press does nothing) and keeps focus. Cancel stays live
-   *  unless the dialog's ways out are held (`setCloseHeld`). */
+   *  working cursor prints, a second press does nothing) and keeps focus, and cancel is held
+   *  with it. Pair it with `isCloseHeld` in `update`'s context, from the same state, so
+   *  Escape and the veil change nothing either. */
   isBusy?: boolean;
   /** The action cannot run now (nothing is running; it is blocked): the confirming button is
    *  held, `aria-disabled` without the working cursor, and stays in the keyboard, so focus
@@ -135,7 +130,6 @@ export type ViewInputs = Readonly<{
 }>;
 
 const cardView = (
-  model: Model,
   viewInputs: ViewInputs,
   render: Dialog.RenderInfo,
   h: HtmlBuilder<Message>,
@@ -158,7 +152,7 @@ const cardView = (
     {
       label: "cancel",
       isDefault: isDanger,
-      isDisabled: Dialog.isCloseHeld(model.dialog),
+      isDisabled: isBusy,
       onClick: Message.ClickedCancel(),
       attributes: isDanger ? render.initialFocus : [],
     },
@@ -198,9 +192,9 @@ const cardView = (
  * arm-then-confirm button: red never rests on a button, and an armed button is easy to
  * double-click through.
  *
- * Work that takes a while stays in the dialog: set `isBusy` while it runs, `close` once it
- * has landed, and on failure keep it open with the error in `toDetailView`. Hold its ways
- * out with `setCloseHeld` too when the reader must stay to see how it ends.
+ * Work that takes a while stays in the dialog: set `isBusy` while it runs (and `isCloseHeld`
+ * in `update`'s context), `close` once it has landed, and on failure keep it open with the
+ * error in `toDetailView`.
  */
 export const view = defineView<Model, Message, ViewInputs>((model, viewInputs, h): Html =>
   h.submodel({
@@ -211,7 +205,7 @@ export const view = defineView<Model, Message, ViewInputs>((model, viewInputs, h
       isAlert: viewInputs.isDanger ?? false,
       hasDescription: true,
       toLiveRegionView: viewInputs.toLiveRegionView,
-      toView: (render) => cardView(model, viewInputs, render, h),
+      toView: (render) => cardView(viewInputs, render, h),
     },
     toParentMessage: (message) => Message.GotDialogMessage({ message }),
   }),

package/src/confirmDialog/index.ts

@@ -5,10 +5,8 @@ export {
   close,
   id,
   init,
-  isCloseHeld,
   isOpen,
   open,
-  setCloseHeld,
   update,
   view,
 } from "./confirmDialog.ts";

package/src/dialog/dialog.ts

@@ -13,11 +13,9 @@ import { foldDialog } from "./fold.ts";
 
 // MODEL
 
-/** Schema for a pixel-paper dialog: the `@foldkit/ui` Dialog it is built on, and whether its
- *  ways out are held (`setCloseHeld`). */
+/** Schema for a pixel-paper dialog: the `@foldkit/ui` Dialog it is built on. */
 export const Model = Schema.Struct({
   dialog: UiDialog.Model,
-  isCloseHeld: Schema.Boolean,
 });
 export type Model = typeof Model.Type;
 
@@ -56,7 +54,6 @@ export type InitConfig = Readonly<{ id: string }>;
 /** Creates a closed dialog. */
 export const init = (config: InitConfig): Model => ({
   dialog: UiDialog.init({ id: config.id }),
-  isCloseHeld: false,
 });
 
 // ACCESSORS
@@ -67,9 +64,6 @@ export const id = (model: Model): string => model.dialog.id;
 /** Whether the dialog is open. */
 export const isOpen = (model: Model): boolean => model.dialog.isOpen;
 
-/** Whether the dialog's ways out are held (`setCloseHeld`). */
-export const isCloseHeld = (model: Model): boolean => model.isCloseHeld;
-
 // UPDATE
 
 const toOutMessage = UiDialog.OutMessage.match<OutMessage | undefined>({
@@ -85,17 +79,29 @@ const dialogFold = foldDialog(UiDialog, {
   toParentOutMessage: toOutMessage,
 });
 
+/** What a dialog's update reads from its parent as a Message arrives. */
+export type UpdateContext = Readonly<{
+  /** The reader may not walk away from the work running now (a save whose failure must land
+   *  in this dialog): Escape, a press on the veil and a control given the `closeButton` group
+   *  change nothing and report no `Closed`. Read it from the parent's own state as the
+   *  Message arrives (`isSaving(model)`), so it holds exactly while the work runs, however
+   *  soon after the start a key comes. */
+  isCloseHeld: boolean;
+}>;
+
+const FREE: UpdateContext = { isCloseHeld: false };
+
 // NOTE: @foldkit/ui gap: Dialog has no way to hold a close. Escape, a press on the veil and a
 // control given the `closeButton` group all send `RequestedClose`, so a held dialog reads it
 // by its tag and leaves it out.
-const isHeldClose = (model: Model, message: UiDialog.Message): boolean =>
-  model.isCloseHeld && message._tag === "RequestedClose";
+const isHeldClose = (context: UpdateContext, message: UiDialog.Message): boolean =>
+  context.isCloseHeld && message._tag === "RequestedClose";
 
 /** Processes a dialog Message and returns the next Model, Commands and OutMessage. */
-export const update = (model: Model, message: Message) =>
+export const update = (model: Model, message: Message, context: UpdateContext = FREE) =>
   Message.match<Update.ReturnWithOutMessage<Model, Message, OutMessage>>(message, {
     GotDialogMessage: ({ message: dialogMessage }) =>
-      isHeldClose(model, dialogMessage) ? { model } : dialogFold.update(model, dialogMessage),
+      isHeldClose(context, dialogMessage) ? { model } : dialogFold.update(model, dialogMessage),
     PressedActionKey: () => ({ model }),
   });
 
@@ -103,18 +109,8 @@ export const update = (model: Model, message: Message) =>
  *  first control, and returns to where it was when the dialog closes. */
 export const open = (model: Model): Update.Return<Model, Message> => dialogFold.open(model);
 
-/** Closes the dialog without reporting `Closed`, and lets go of a hold. */
-export const close = (model: Model): Update.Return<Model, Message> =>
-  dialogFold.close(modifyFields(model, { isCloseHeld: () => false }));
-
-/** Holds the dialog's ways out, or lets them go: while held, Escape, a press on the veil and
- *  a control given the `closeButton` group leave it open and report no `Closed`, so the
- *  result of work the reader may not walk away from (a save whose failure must land here)
- *  lands in it. Hold it in the update that starts the work, and let go in the update where
- *  the work fails, or the reader is shut in with the failure; `close` lets go once it lands.
- *  Hold the card's own close controls too (`Card.formView`'s `isBusy`). */
-export const setCloseHeld = (model: Model, isHeld: boolean): Model =>
-  modifyFields(model, { isCloseHeld: () => isHeld });
+/** Closes the dialog without reporting `Closed`. */
+export const close = (model: Model): Update.Return<Model, Message> => dialogFold.close(model);
 
 // ACTION BAR KEYS
 

package/src/dialog/fold.ts

@@ -1,6 +1,8 @@
 import { Option } from "effect";
 import * as Update from "foldkit/update";
 
+import type { UpdateContext } from "./dialog.ts";
+
 // FOLD
 
 type ChildReturn<ChildModel, ChildMessage, ChildOutMessage> = Update.ReturnWithOutMessage<
@@ -15,6 +17,7 @@ type DialogChild<ChildModel, ChildMessage, ChildOutMessage> = Readonly<{
   update: (
     model: ChildModel,
     message: ChildMessage,
+    context: UpdateContext,
   ) => ChildReturn<ChildModel, ChildMessage, ChildOutMessage>;
   open: (model: ChildModel) => ChildReturn<ChildModel, ChildMessage, ChildOutMessage>;
   close: (model: ChildModel) => ChildReturn<ChildModel, ChildMessage, ChildOutMessage>;
@@ -36,6 +39,10 @@ type DialogFoldConfig<
    *  veil, a close button). Without it the dialog's OutMessages report nothing: a parent
    *  that reads `isOpen` when it needs to. */
   toParentOutMessage?: (outMessage: ChildOutMessage) => ParentOutMessage | undefined;
+  /** Whether the dialog's ways out are held, read from the parent's own state as each
+   *  Message arrives (`(model) => model.isSaving`). Free when not given. See
+   *  `Dialog.UpdateContext`. */
+  isCloseHeld?: (model: ParentModel) => boolean;
 }>;
 
 /** The dialog folded into its parent: a dialog Message, and opening and closing it. */
@@ -44,6 +51,14 @@ type DialogFold<ParentModel, ParentMessage, ParentOutMessage, ChildMessage> = Re
     model: ParentModel,
     message: ChildMessage,
   ) => Update.ReturnWithOutMessage<ParentModel, ParentMessage, ParentOutMessage>;
+  /** The update a parent that is itself a dialog (ConfirmDialog) runs with the hold its own
+   *  parent gave it. */
+  updateWith: (
+    context: UpdateContext,
+  ) => (
+    model: ParentModel,
+    message: ChildMessage,
+  ) => Update.ReturnWithOutMessage<ParentModel, ParentMessage, ParentOutMessage>;
   open: (model: ParentModel) => Update.Return<ParentModel, ParentMessage>;
   close: (model: ParentModel) => Update.Return<ParentModel, ParentMessage>;
 }>;
@@ -98,14 +113,18 @@ export const foldDialog = <
   // `RequestedOpen`, which reports `Opened`), and so can its update, so each fold needs a
   // step for an OutMessage. This one keeps the parent's Model: a step reports nothing.
   const foldOutMessage = () => (model: ParentModel) => ({ model });
-  const { toParentOutMessage } = config;
-  const update =
-    toParentOutMessage === undefined
-      ? Update.foldChild({ update: child.update, ...lift, foldOutMessage })
-      : Update.foldChild({ update: child.update, ...lift, toParentOutMessage });
+  const { toParentOutMessage, isCloseHeld = () => false } = config;
+  const updateWith = (context: UpdateContext) => {
+    const childUpdate = (model: ChildModel, message: ChildMessage) =>
+      child.update(model, message, context);
+    return toParentOutMessage === undefined
+      ? Update.foldChild({ update: childUpdate, ...lift, foldOutMessage })
+      : Update.foldChild({ update: childUpdate, ...lift, toParentOutMessage });
+  };
 
   return {
-    update,
+    update: (model, message) => updateWith({ isCloseHeld: isCloseHeld(model) })(model, message),
+    updateWith,
     open: Update.foldChildStep({ update: child.open, ...lift, foldOutMessage }),
     close: Update.foldChildStep({ update: child.close, ...lift, foldOutMessage }),
   };

package/src/dialog/index.ts

@@ -6,13 +6,11 @@ export {
   close,
   id,
   init,
-  isCloseHeld,
   isOpen,
   open,
   sceneMounts,
-  setCloseHeld,
   update,
   view,
 } from "./dialog.ts";
-export type { InitConfig, Placement, RenderInfo, ViewInputs } from "./dialog.ts";
+export type { InitConfig, Placement, RenderInfo, UpdateContext, ViewInputs } from "./dialog.ts";
 export { foldDialog } from "./fold.ts";