foldkit-primitives 0.3.0 → 0.5.0

package/dist/interaction/index.d.mts

@@ -1,4 +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$1 } from "../move-DNiMPcuf.mjs";
+import { A as ScrollLock, C as targetOf, D as MoveStarted, E as MoveEnded, M as tabbableWithin, O as Moved, S as Targets, T as Move, _ as boxOf, a as TextEdited, b as TargetHovered, c as DRAG_THRESHOLD, d as DragFact, f as DragPlace, g as PointerDrag, h as DraggedOver, i as TextCommitted, j as FocusScope, k as HideOutside, l as DragCancelled, m as DragZone, n as EditableText, o as TextFact, p as DragStarted, r as TextCancelled, s as textOf, t as EditAsked, u as DragDropped, v as zoneOf, w as Fact$1, x as TargetPressed, y as TargetFact } from "../editable-text-CKkS_mWt.mjs";
 import { a as modalityOfKey, i as Modality, r as InputModalityModel, t as InputModality } from "../input-modality-DGOhAknO.mjs";
 import { Schema } from "effect";
 import * as Mount from "foldkit/mount";
@@ -6,7 +6,7 @@ import { Bundle, Declared } from "foldkit-bundle";
 import { Behavior, Behaviors, SlotItem } from "foldkit-mixins";
 import { Attribute, Html, HtmlBuilder, KeyboardModifiers } from "foldkit/html";
 declare namespace dismiss_layer_d_exports {
-  export { BehaviorOptions$10 as BehaviorOptions, Dismiss, LAYER_ATTRIBUTE, Layer$1 as Layer, Message$8 as Message, Model$8 as Model, TRIGGER_ATTRIBUTE, behavior$10 as behavior, bundle$8 as bundle, layersOnPath, toDismiss };
+  export { BehaviorOptions$14 as BehaviorOptions, Dismiss, LAYER_ATTRIBUTE, Layer$1 as Layer, Message$9 as Message, Model$9 as Model, TRIGGER_ATTRIBUTE, behavior$14 as behavior, bundle$9 as bundle, layersOnPath, toDismiss };
 }
 declare const LAYER_ATTRIBUTE = "data-foldkit-plus-layer";
 declare const TRIGGER_ATTRIBUTE = "data-foldkit-plus-layer-trigger";
@@ -19,7 +19,7 @@ declare const Layer$1: Schema.Struct<{
   readonly escape: Schema.Boolean;
 }>;
 type Layer$1 = typeof Layer$1.Type;
-declare const Model$8: Schema.Struct<{
+declare const Model$9: Schema.Struct<{
   /** The open layers at the last event, bottom to top. */
   readonly layers: Schema.$Array<Schema.Struct<{
     readonly id: Schema.String;
@@ -29,8 +29,8 @@ declare const Model$8: Schema.Struct<{
     readonly escape: Schema.Boolean;
   }>>;
 }>;
-type Model$8 = typeof Model$8.Type;
-declare const Message$8: import("foldkit/message").MessageUnion<{
+type Model$9 = typeof Model$9.Type;
+declare const Message$9: import("foldkit/message").MessageUnion<{
   /** A pointer went down; `inside` are the layers whose element or trigger was on the event's path. */
   readonly PressedAt: {
     readonly layers: Schema.$Array<Schema.Struct<{
@@ -52,14 +52,14 @@ declare const Message$8: import("foldkit/message").MessageUnion<{
     }>>;
   };
 }>;
-type Message$8 = typeof Message$8.Type;
+type Message$9 = typeof Message$9.Type;
 declare const Dismiss: Schema.TaggedStruct<"Dismiss", {
   readonly ids: Schema.$Array<Schema.String>;
 }>;
 type Dismiss = typeof Dismiss.Type;
 /** Which layers a press inside `inside` dismisses: every layer above the topmost one hit, or all when none was. */
 declare const toDismiss: (layers: ReadonlyArray<Layer$1>, inside: ReadonlyArray<string>) => ReadonlyArray<string>;
-declare const bundle$8: Bundle.Bundle<"DismissLayer", void, {
+declare const bundle$9: Bundle.Bundle<"DismissLayer", void, {
   readonly layers: readonly {
     readonly id: string;
     readonly outside: boolean;
@@ -86,7 +86,7 @@ declare const bundle$8: Bundle.Bundle<"DismissLayer", void, {
 }, never, never, void, {}, {}>;
 /** The layer ids whose element or trigger is on the event's composed path. */
 declare const layersOnPath: (path: ReadonlyArray<EventTarget>) => ReadonlyArray<string>;
-interface BehaviorOptions$10<Input, Slots> {
+interface BehaviorOptions$14<Input, Slots> {
   /** The layer's root, rendered only while the layer is open. */
   readonly layer: keyof Slots & string;
   /** The element that opens the layer, so a press on it is inside. */
@@ -103,11 +103,23 @@ interface BehaviorOptions$10<Input, Slots> {
  * parent Model is the whole lifecycle. Not for an element with `popover`,
  * which the browser dismisses itself.
  */
-declare const behavior$10: <Field extends string>(_declared: Declared<typeof bundle$8, Field>) => <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$10<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$14: <Field extends string>(_declared: Declared<typeof bundle$9, Field>) => <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$14<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace editable_text_d_exports {
+  export { BehaviorOptions$13 as BehaviorOptions, EditAsked, TextCancelled, TextCommitted, TextEdited, TextFact, behavior$13 as behavior, EditableText as mount, textOf };
+}
+interface BehaviorOptions$13<Slots, ParentMessage> {
+  /** The slot holding the fields. */
+  readonly container: keyof Slots & string;
+  /** The attribute that marks a field, holding its name. */
+  readonly attribute: string;
+  /** Turns each fact into the view's Message. */
+  readonly toMessage: (fact: TextFact) => ParentMessage;
+}
+declare const behavior$13: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$13<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace focus_scope_d_exports {
-  export { BehaviorOptions$9 as BehaviorOptions, behavior$9 as behavior, FocusScope as mount, tabbableWithin };
+  export { BehaviorOptions$12 as BehaviorOptions, behavior$12 as behavior, FocusScope as mount, tabbableWithin };
 }
-interface BehaviorOptions$9<Slots> {
+interface BehaviorOptions$12<Slots> {
   readonly container: keyof Slots & string;
   /** Keep Tab, Shift+Tab, and a stray focus inside. Default `true`. */
   readonly contain?: boolean;
@@ -123,32 +135,32 @@ interface BehaviorOptions$9<Slots> {
  * `restore`, focus returns to the element that had it. A dialog that is not
  * a native `<dialog>`, a menu, or a command palette takes this.
  */
-declare const behavior$9: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$9<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$12: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$12<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace focus_visible_d_exports {
-  export { BehaviorOptions$8 as BehaviorOptions, Modality, InputModalityModel as Model, behavior$8 as behavior, InputModality as bundle, modalityOfKey };
+  export { BehaviorOptions$11 as BehaviorOptions, Modality, InputModalityModel as Model, behavior$11 as behavior, InputModality as bundle, modalityOfKey };
 }
-interface BehaviorOptions$8<Slots> {
+interface BehaviorOptions$11<Slots> {
   readonly target: keyof Slots & string;
 }
-declare const behavior$8: <Field extends string>(declared: Declared<typeof InputModality, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: InputModalityModel; }, ParentMessage>(options: BehaviorOptions$8<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$11: <Field extends string>(declared: Declared<typeof InputModality, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: InputModalityModel; }, ParentMessage>(options: BehaviorOptions$11<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace roving_tabindex_d_exports {
-  export { Args$7 as Args, BehaviorOptions$7 as BehaviorOptions, Direction, Message$7 as Message, Model$7 as Model, MoveOptions$1 as MoveOptions, Orientation, behavior$7 as behavior, bundle$7 as bundle, idSelector, itemAttributes, move$1 as move, tabStop };
+  export { Args$8 as Args, BehaviorOptions$10 as BehaviorOptions, Direction, Message$8 as Message, Model$8 as Model, MoveOptions$1 as MoveOptions, Orientation, behavior$10 as behavior, bundle$8 as bundle, idSelector, itemAttributes, move$2 as move, tabStop$1 as tabStop };
 }
 declare const Orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
 type Orientation = typeof Orientation.Type;
-declare const Model$7: Schema.Struct<{
+declare const Model$8: Schema.Struct<{
   /** The current item's id, or `null` before any item has been focused. */
   readonly current: Schema.NullOr<Schema.String>;
 }>;
-type Model$7 = typeof Model$7.Type;
-declare const Message$7: import("foldkit/message").MessageUnion<{
+type Model$8 = typeof Model$8.Type;
+declare const Message$8: import("foldkit/message").MessageUnion<{
   /** An item became current: the user focused it, or a key moved there. */
   readonly Focused: {
     readonly id: Schema.String;
   };
 }>;
-type Message$7 = typeof Message$7.Type;
-declare const Args$7: Schema.Struct<{
+type Message$8 = typeof Message$8.Type;
+declare const Args$8: Schema.Struct<{
   readonly orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
   /** Wrap from the last enabled item to the first, and back. */
   readonly loop: Schema.Boolean;
@@ -156,8 +168,8 @@ declare const Args$7: Schema.Struct<{
    *  `aria-activedescendant` instead of moving focus. */
   readonly virtual: Schema.Boolean;
 }>;
-type Args$7 = typeof Args$7.Type;
-declare const bundle$7: Bundle.Bundle<"RovingTabindex", {
+type Args$8 = typeof Args$8.Type;
+declare const bundle$8: Bundle.Bundle<"RovingTabindex", {
   readonly orientation: "vertical" | "horizontal" | "both";
   readonly loop: boolean;
   readonly virtual: boolean;
@@ -182,10 +194,10 @@ interface MoveOptions$1 {
  * item. Under `rtl`, left and right swap. PageUp and PageDown move by `page`
  * and clamp at the ends, never wrapping.
  */
-declare const move$1: (enabled: ReadonlyArray<number>, current: number, key: string, modifiers: KeyboardModifiers, options: MoveOptions$1) => number | undefined;
+declare const move$2: (enabled: ReadonlyArray<number>, current: number, key: string, modifiers: KeyboardModifiers, options: MoveOptions$1) => number | undefined;
 /** The item that holds the tab stop: the current one, else the first enabled. */
-declare const tabStop: (items: Behaviors.Collection.Items<unknown>, current: string | null) => number;
-interface BehaviorOptions$7<Input, Slots> {
+declare const tabStop$1: (items: Behaviors.Collection.Items<unknown>, current: string | null) => number;
+interface BehaviorOptions$10<Input, Slots> {
   /** The slot that receives the arrow keys. */
   readonly container: keyof Slots & string;
   /** The slot rendered once per item; must carry the item's id (see `Behaviors.Collection`). */
@@ -213,23 +225,23 @@ declare const itemAttributes: <ParentMessage>(h: HtmlBuilder<ParentMessage>, ite
  * attributes are data, so a view that no longer attaches this leaves no
  * `tabindex` behind.
  */
-declare const behavior$7: <Field extends string>(declared: Declared<typeof bundle$7, Field>, args: Args$7) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$7; }, ParentMessage>(options: BehaviorOptions$7<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$10: <Field extends string>(declared: Declared<typeof bundle$8, Field>, args: Args$8) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$8; }, ParentMessage>(options: BehaviorOptions$10<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace grid_navigation_d_exports {
-  export { Args$6 as Args, BehaviorOptions$6 as BehaviorOptions, Message$6 as Message, Model$6 as Model, MoveOptions, behavior$6 as behavior, bundle$6 as bundle, move };
+  export { Args$7 as Args, BehaviorOptions$9 as BehaviorOptions, Message$7 as Message, Model$7 as Model, MoveOptions, behavior$9 as behavior, bundle$7 as bundle, move$1 as move };
 }
-declare const Model$6: Schema.Struct<{
+declare const Model$7: Schema.Struct<{
   /** The current cell's id, or `null` before any cell has been focused. */
   readonly current: Schema.NullOr<Schema.String>;
 }>;
-type Model$6 = typeof Model$6.Type;
-declare const Message$6: import("foldkit/message").MessageUnion<{
+type Model$7 = typeof Model$7.Type;
+declare const Message$7: import("foldkit/message").MessageUnion<{
   /** A cell became current: the user focused it, or a key moved there. */
   readonly Focused: {
     readonly id: Schema.String;
   };
 }>;
-type Message$6 = typeof Message$6.Type;
-declare const Args$6: Schema.Struct<{
+type Message$7 = typeof Message$7.Type;
+declare const Args$7: Schema.Struct<{
   /** Cells per row; the last row may be short. */
   readonly columns: Schema.Number;
   /** Left and right continue into the previous and next row; up and down
@@ -239,8 +251,8 @@ declare const Args$6: Schema.Struct<{
    *  `aria-activedescendant` instead of moving focus. */
   readonly virtual: Schema.Boolean;
 }>;
-type Args$6 = typeof Args$6.Type;
-declare const bundle$6: Bundle.Bundle<"GridNavigation", {
+type Args$7 = typeof Args$7.Type;
+declare const bundle$7: Bundle.Bundle<"GridNavigation", {
   readonly columns: number;
   readonly wrap: boolean;
   readonly virtual: boolean;
@@ -266,8 +278,8 @@ interface MoveOptions {
  * the first enabled cell and a backward key on the last. Under `rtl`, left
  * and right swap.
  */
-declare const move: (enabled: ReadonlyArray<number>, count: number, current: number, key: string, modifiers: KeyboardModifiers, options: MoveOptions) => number | undefined;
-interface BehaviorOptions$6<Input, Slots> {
+declare const move$1: (enabled: ReadonlyArray<number>, count: number, current: number, key: string, modifiers: KeyboardModifiers, options: MoveOptions) => number | undefined;
+interface BehaviorOptions$9<Input, Slots> {
   /** The slot that receives the arrow keys. */
   readonly container: keyof Slots & string;
   /** The slot rendered once per cell; must carry the cell's id (see `Behaviors.Collection`). */
@@ -283,7 +295,7 @@ interface BehaviorOptions$6<Input, Slots> {
  * only dispatch and point with `aria-activedescendant`; each cell gets
  * `tabindex` 0 or -1 and reports `Focused` when focused.
  */
-declare const behavior$6: <Field extends string>(declared: Declared<typeof bundle$6, Field>, args: Args$6) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$6; }, ParentMessage>(options: BehaviorOptions$6<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$9: <Field extends string>(declared: Declared<typeof bundle$7, Field>, args: Args$7) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$7; }, ParentMessage>(options: BehaviorOptions$9<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace layers_d_exports {
   export { hideOutside, HideOutside as hideOutsideMount, scrollLock, ScrollLock as scrollLockMount };
 }
@@ -296,11 +308,11 @@ declare const hideOutside: <Slots>(slots: Slots) => <Input, ParentMessage>(optio
   readonly container: keyof Slots & string;
 }) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace live_announce_d_exports {
-  export { Args$5 as Args, Message$5 as Message, Model$5 as Model, Politeness, REGION_ATTRIBUTE, bundle$5 as bundle, reread, say, view };
+  export { Args$6 as Args, Message$6 as Message, Model$6 as Model, Politeness, REGION_ATTRIBUTE, bundle$6 as bundle, reread, say, view };
 }
 declare const Politeness: Schema.Literals<readonly ["polite", "assertive"]>;
 type Politeness = typeof Politeness.Type;
-declare const Model$5: Schema.Struct<{
+declare const Model$6: Schema.Struct<{
   readonly polite: Schema.String;
   readonly assertive: Schema.String;
   /** Waiting for the debounce to read. */
@@ -310,8 +322,8 @@ declare const Model$5: Schema.Struct<{
   }>>;
   readonly generation: Schema.Number;
 }>;
-type Model$5 = typeof Model$5.Type;
-declare const Message$5: import("foldkit/message").MessageUnion<{
+type Model$6 = typeof Model$6.Type;
+declare const Message$6: import("foldkit/message").MessageUnion<{
   readonly Announced: {
     readonly message: Schema.String;
     readonly politeness: Schema.Literals<readonly ["polite", "assertive"]>;
@@ -323,17 +335,17 @@ declare const Message$5: import("foldkit/message").MessageUnion<{
     readonly generation: Schema.Number;
   };
 }>;
-type Message$5 = typeof Message$5.Type;
-declare const Args$5: Schema.Struct<{
+type Message$6 = typeof Message$6.Type;
+declare const Args$6: Schema.Struct<{
   /** A burst of announcements inside this window reads once, the last one. */
   readonly debounceMs: Schema.Number;
   /** How long the text stays in the region. */
   readonly clearAfterMs: Schema.Number;
 }>;
-type Args$5 = typeof Args$5.Type;
+type Args$6 = typeof Args$6.Type;
 /** The text to put in the region so that `next` is read even when it equals `current`. */
 declare const reread: (current: string, next: string) => string;
-declare const bundle$5: Bundle.Bundle<"LiveAnnounce", {
+declare const bundle$6: Bundle.Bundle<"LiveAnnounce", {
   readonly debounceMs: number;
   readonly clearAfterMs: number;
 }, {
@@ -356,24 +368,24 @@ declare const bundle$5: Bundle.Bundle<"LiveAnnounce", {
   readonly generation: number;
 }, never, never, never, void, {}, {}>;
 /** The parent Message that announces `text`, to return from `update` or `onOut`. */
-declare const say: <Field extends string>(declared: Declared<typeof bundle$5, Field>) => <ParentMessage>(text: string, politeness?: Politeness) => ParentMessage;
+declare const say: <Field extends string>(declared: Declared<typeof bundle$6, Field>) => <ParentMessage>(text: string, politeness?: Politeness) => ParentMessage;
 declare const REGION_ATTRIBUTE = "data-foldkit-plus-live";
 /**
  * The two live regions. Render once, anywhere in the page, and hide them
  * visually with a rule on `[data-foldkit-plus-live]`; they must stay in the
  * accessibility tree, so no `display: none`.
  */
-declare const view: <ParentMessage>(model: Model$5, h: HtmlBuilder<ParentMessage>) => Html;
+declare const view: <ParentMessage>(model: Model$6, h: HtmlBuilder<ParentMessage>) => Html;
 declare namespace list_navigation_d_exports {
-  export { Args$4 as Args, BehaviorOptions$5 as BehaviorOptions, KeyOutcome, Message$4 as Message, Model$4 as Model, behavior$5 as behavior, bundle$4 as bundle, keyOutcome };
+  export { Args$5 as Args, BehaviorOptions$8 as BehaviorOptions, KeyOutcome, Message$5 as Message, Model$5 as Model, behavior$8 as behavior, bundle$5 as bundle, keyOutcome };
 }
-declare const Model$4: Schema.Struct<{
+declare const Model$5: Schema.Struct<{
   readonly current: Schema.NullOr<Schema.String>;
   readonly query: Schema.String;
   readonly generation: Schema.Number;
 }>;
-type Model$4 = typeof Model$4.Type;
-declare const Message$4: import("foldkit/message").MessageUnion<{
+type Model$5 = typeof Model$5.Type;
+declare const Message$5: import("foldkit/message").MessageUnion<{
   /** An item became current: focused, or reached by a key. */
   readonly Focused: {
     readonly id: Schema.String;
@@ -388,8 +400,8 @@ declare const Message$4: import("foldkit/message").MessageUnion<{
   };
   readonly Cleared: {};
 }>;
-type Message$4 = typeof Message$4.Type;
-declare const Args$4: Schema.Struct<{
+type Message$5 = typeof Message$5.Type;
+declare const Args$5: Schema.Struct<{
   readonly orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
   readonly loop: Schema.Boolean;
   readonly virtual: Schema.Boolean;
@@ -398,8 +410,8 @@ declare const Args$4: Schema.Struct<{
   /** How many enabled items PageUp and PageDown move. */
   readonly page: Schema.Number;
 }>;
-type Args$4 = typeof Args$4.Type;
-declare const bundle$4: Bundle.Bundle<"ListNavigation", {
+type Args$5 = typeof Args$5.Type;
+declare const bundle$5: Bundle.Bundle<"ListNavigation", {
   readonly orientation: "vertical" | "horizontal" | "both";
   readonly loop: boolean;
   readonly virtual: boolean;
@@ -422,7 +434,7 @@ declare const bundle$4: Bundle.Bundle<"ListNavigation", {
   readonly _tag: "Focused";
   readonly id: string;
 }, never, never, never, void, {}, {}>;
-interface BehaviorOptions$5<Input, Slots> {
+interface BehaviorOptions$8<Input, Slots> {
   readonly container: keyof Slots & string;
   /** The slot rendered once per item; must carry the item's id (see `Behaviors.Collection`). */
   readonly item: keyof Slots & string;
@@ -454,19 +466,19 @@ declare const keyOutcome: (items: Behaviors.Collection.Items<unknown>, texts: Re
  * `OnFocus` as under `RovingTabindex`. Under `virtual` nothing takes DOM focus
  * and the container carries `aria-activedescendant`.
  */
-declare const behavior$5: <Field extends string>(declared: Declared<typeof bundle$4, Field>, args: Args$4) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$4; }, ParentMessage>(options: BehaviorOptions$5<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$8: <Field extends string>(declared: Declared<typeof bundle$5, Field>, args: Args$5) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$5; }, ParentMessage>(options: BehaviorOptions$8<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace long_press_d_exports {
-  export { Args$3 as Args, BehaviorOptions$4 as BehaviorOptions, LongPressed, Message$3 as Message, Model$3 as Model, behavior$4 as behavior, bundle$3 as bundle };
+  export { Args$4 as Args, BehaviorOptions$7 as BehaviorOptions, LongPressed, Message$4 as Message, Model$4 as Model, behavior$7 as behavior, bundle$4 as bundle };
 }
-declare const Model$3: Schema.Struct<{
+declare const Model$4: Schema.Struct<{
   /** Down, and the threshold has not passed. */
   readonly holding: Schema.Boolean;
   readonly pointerId: Schema.NullOr<Schema.Number>;
   readonly key: Schema.NullOr<Schema.String>;
   readonly generation: Schema.Number;
 }>;
-type Model$3 = typeof Model$3.Type;
-declare const Message$3: import("foldkit/message").MessageUnion<{
+type Model$4 = typeof Model$4.Type;
+declare const Message$4: import("foldkit/message").MessageUnion<{
   readonly PointerDown: {
     readonly pointerId: Schema.Number;
     readonly button: Schema.Number;
@@ -497,16 +509,16 @@ declare const Message$3: import("foldkit/message").MessageUnion<{
     readonly pointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
   };
 }>;
-type Message$3 = typeof Message$3.Type;
+type Message$4 = typeof Message$4.Type;
 declare const LongPressed: Schema.TaggedStruct<"LongPressed", {
   readonly pointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
 }>;
 type LongPressed = typeof LongPressed.Type;
-declare const Args$3: Schema.Struct<{
+declare const Args$4: Schema.Struct<{
   readonly thresholdMs: Schema.Number;
 }>;
-type Args$3 = typeof Args$3.Type;
-declare const bundle$3: Bundle.Bundle<"LongPress", {
+type Args$4 = typeof Args$4.Type;
+declare const bundle$4: Bundle.Bundle<"LongPress", {
   readonly thresholdMs: number;
 }, {
   readonly holding: boolean;
@@ -546,7 +558,7 @@ declare const bundle$3: Bundle.Bundle<"LongPress", {
   readonly _tag: "LongPressed";
   readonly pointerType: "keyboard" | "virtual" | "mouse" | "touch" | "pen";
 }, never, never, void, {}, {}>;
-interface BehaviorOptions$4<Slots> {
+interface BehaviorOptions$7<Slots> {
   readonly target: keyof Slots & string;
 }
 /**
@@ -555,22 +567,22 @@ interface BehaviorOptions$4<Slots> {
  * `LongPress` on one slot are refused by the resolver (two Mounts of one
  * name), so today a slot takes one of them.
  */
-declare const behavior$4: <Field extends string>(declared: Declared<typeof bundle$3, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$3; }, ParentMessage>(options: BehaviorOptions$4<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$7: <Field extends string>(declared: Declared<typeof bundle$4, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$4; }, ParentMessage>(options: BehaviorOptions$7<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace move_d_exports {
-  export { BehaviorOptions$3 as BehaviorOptions, Fact$1 as Fact, MoveEnded, MoveStarted, Moved, behavior$3 as behavior, Move as mount };
+  export { BehaviorOptions$6 as BehaviorOptions, Fact$1 as Fact, MoveEnded, MoveStarted, Moved, behavior$6 as behavior, Move as mount };
 }
-interface BehaviorOptions$3<Slots, ParentMessage> {
+interface BehaviorOptions$6<Slots, ParentMessage> {
   readonly handle: keyof Slots & string;
   /** Turns each fact into the view's Message. */
   readonly toMessage: (fact: Fact$1) => ParentMessage;
 }
-declare const behavior$3: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$3<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$6: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$6<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace press_d_exports {
-  export { Args$2 as Args, BehaviorOptions$2 as BehaviorOptions, Fact, Message$2 as Message, Model$2 as Model, PointerType, Pressed, behavior$2 as behavior, bundle$2 as bundle, events };
+  export { Args$3 as Args, BehaviorOptions$5 as BehaviorOptions, Fact, Message$3 as Message, Model$3 as Model, PointerType, Pressed, behavior$5 as behavior, bundle$3 as bundle, events };
 }
 declare const PointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
 type PointerType = typeof PointerType.Type;
-declare const Model$2: Schema.Struct<{
+declare const Model$3: Schema.Struct<{
   /** Down and not yet released or cancelled. For styling. */
   readonly pressed: Schema.Boolean;
   /** The pointer that pressed, so another pointer's up cannot release it. */
@@ -581,8 +593,8 @@ declare const Model$2: Schema.Struct<{
   readonly suppressing: Schema.NullOr<Schema.Number>;
   readonly generation: Schema.Number;
 }>;
-type Model$2 = typeof Model$2.Type;
-declare const Message$2: import("foldkit/message").MessageUnion<{
+type Model$3 = typeof Model$3.Type;
+declare const Message$3: import("foldkit/message").MessageUnion<{
   readonly PointerDown: {
     readonly pointerId: Schema.Number;
     readonly button: Schema.Number;
@@ -613,19 +625,19 @@ declare const Message$2: import("foldkit/message").MessageUnion<{
     readonly generation: Schema.Number;
   };
 }>;
-type Message$2 = typeof Message$2.Type;
+type Message$3 = typeof Message$3.Type;
 declare const Pressed: Schema.TaggedStruct<"Pressed", {
   readonly pointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
   /** Shift was held, for a range selection. */
   readonly shiftKey: Schema.Boolean;
 }>;
 type Pressed = typeof Pressed.Type;
-declare const Args$2: Schema.Struct<{
+declare const Args$3: Schema.Struct<{
   /** How long after a pointer press a `click` is taken for its ghost. */
   readonly clickSuppressionMs: Schema.Number;
 }>;
-type Args$2 = typeof Args$2.Type;
-declare const bundle$2: Bundle.Bundle<"Press", {
+type Args$3 = typeof Args$3.Type;
+declare const bundle$3: Bundle.Bundle<"Press", {
   readonly clickSuppressionMs: number;
 }, {
   readonly pressed: boolean;
@@ -667,7 +679,7 @@ declare const bundle$2: Bundle.Bundle<"Press", {
   readonly shiftKey: boolean;
 }, never, never, void, {}, {}>;
 /** What the element reports; `Unsuppressed` comes from the timer, not the DOM. */
-type Fact = Exclude<Message$2, {
+type Fact = Exclude<Message$3, {
   readonly _tag: 'Unsuppressed';
 }>;
 /**
@@ -703,7 +715,7 @@ declare const events: Mount.MountDefinitionNoArgs<"PressEvents", {
   readonly detail: number;
   readonly shiftKey: boolean;
 }>;
-interface BehaviorOptions$2<Input, Slots> {
+interface BehaviorOptions$5<Input, Slots> {
   readonly target: keyof Slots & string;
   /** Marks the target `aria-disabled`, which also silences its events. */
   readonly disabled?: (input: Input) => boolean;
@@ -714,20 +726,20 @@ interface BehaviorOptions$2<Input, Slots> {
  * decides nothing; a click, a touch, Enter, Space, or an assistive
  * technology's click all reach `update` and come out as one `Pressed`.
  */
-declare const behavior$2: <Field extends string>(declared: Declared<typeof bundle$2, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$2; }, ParentMessage>(options: BehaviorOptions$2<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare const behavior$5: <Field extends string>(declared: Declared<typeof bundle$3, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$3; }, ParentMessage>(options: BehaviorOptions$5<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace selection_d_exports {
-  export { Args$1 as Args, BehaviorOptions$1 as BehaviorOptions, Message$1 as Message, Mode, Model$1 as Model, behavior$1 as behavior, between, bundle$1 as bundle };
+  export { Args$2 as Args, BehaviorOptions$4 as BehaviorOptions, Message$2 as Message, Mode, Model$2 as Model, behavior$4 as behavior, between, bundle$2 as bundle };
 }
 declare const Mode: Schema.Literals<readonly ["single", "multiple", "none"]>;
 type Mode = typeof Mode.Type;
-declare const Model$1: Schema.Struct<{
+declare const Model$2: Schema.Struct<{
   /** In selection order. */
   readonly selected: Schema.$Array<Schema.String>;
   /** Where the last plain selection happened; a range extends from it. */
   readonly anchor: Schema.NullOr<Schema.String>;
 }>;
-type Model$1 = typeof Model$1.Type;
-declare const Message$1: import("foldkit/message").MessageUnion<{
+type Model$2 = typeof Model$2.Type;
+declare const Message$2: import("foldkit/message").MessageUnion<{
   /** A plain activation: replaces in single mode, toggles in multiple mode. */
   readonly Activated: {
     readonly id: Schema.String;
@@ -742,16 +754,16 @@ declare const Message$1: import("foldkit/message").MessageUnion<{
   };
   readonly Cleared: {};
 }>;
-type Message$1 = typeof Message$1.Type;
-declare const Args$1: Schema.Struct<{
+type Message$2 = typeof Message$2.Type;
+declare const Args$2: Schema.Struct<{
   readonly mode: Schema.Literals<readonly ["single", "multiple", "none"]>;
   /** In single mode, whether activating the selected item deselects it. */
   readonly allowEmpty: Schema.Boolean;
 }>;
-type Args$1 = typeof Args$1.Type;
+type Args$2 = typeof Args$2.Type;
 /** The ids between `from` and `to` in `order`, inclusive, in `order`'s order. */
 declare const between: (order: ReadonlyArray<string>, from: string | null, to: string) => ReadonlyArray<string>;
-declare const bundle$1: Bundle.Bundle<"Selection", {
+declare const bundle$2: Bundle.Bundle<"Selection", {
   readonly mode: "single" | "multiple" | "none";
   readonly allowEmpty: boolean;
 }, {
@@ -770,7 +782,7 @@ declare const bundle$1: Bundle.Bundle<"Selection", {
   readonly _tag: "Replaced";
   readonly ids: readonly string[];
 }, never, never, never, void, {}, {}>;
-interface BehaviorOptions$1<Input, Slots> {
+interface BehaviorOptions$4<Input, Slots> {
   /** The slot holding the items, for `aria-multiselectable`. */
   readonly container?: keyof Slots & string;
   /** The slot rendered once per item; must carry the item's id. */
@@ -785,6 +797,149 @@ interface BehaviorOptions$1<Input, Slots> {
  * `aria-multiselectable` on the container in multiple mode; wires `OnClick`
  * to `Activated` unless told not to. A disabled item gets no click.
  */
+declare const behavior$4: <Field extends string>(declared: Declared<typeof bundle$2, Field>, args: Args$2) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$2; }, ParentMessage>(options: BehaviorOptions$4<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace targets_d_exports {
+  export { BehaviorOptions$3 as BehaviorOptions, TargetFact, TargetHovered, TargetPressed, behavior$3 as behavior, Targets as mount, targetOf };
+}
+interface BehaviorOptions$3<Slots, ParentMessage> {
+  /** The slot holding the marked descendants. */
+  readonly container: keyof Slots & string;
+  /** The attribute that marks a descendant, holding its id. */
+  readonly attribute: string;
+  /** Prevent a press's default, such as a link navigating. Default `false`. */
+  readonly preventDefault?: boolean;
+  /** Turns each fact into the view's Message. */
+  readonly toMessage: (fact: TargetFact) => ParentMessage;
+}
+declare const behavior$3: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$3<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace pointer_drag_d_exports {
+  export { BehaviorOptions$2 as BehaviorOptions, DRAG_THRESHOLD, DragCancelled, DragDropped, DragFact, DragPlace, DragStarted, DragZone, DraggedOver, behavior$2 as behavior, boxOf, PointerDrag as mount, zoneOf };
+}
+interface BehaviorOptions$2<Slots, ParentMessage> {
+  /** The slot holding the marked descendants. */
+  readonly container: keyof Slots & string;
+  /** The attribute that marks a descendant, holding its id. */
+  readonly attribute: string;
+  /**
+   * Where a drag may land when not among the container's own: elements marked
+   * by `attribute` inside the one `within` selects, such as a page for a palette.
+   */
+  readonly targets?: {
+    readonly attribute: string;
+    readonly within: string;
+  };
+  /** Turns each fact into the view's Message. */
+  readonly toMessage: (fact: DragFact) => ParentMessage;
+}
+declare const behavior$2: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$2<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace tree_navigation_d_exports {
+  export { Action, Args$1 as Args, BehaviorOptions$1 as BehaviorOptions, Message$1 as Message, Model$1 as Model, Row, Shown, behavior$1 as behavior, bundle$1 as bundle, isOpen, move, shown, tabStop };
+}
+declare const Model$1: Schema.Struct<{
+  /** The current row's id, or `null` before any row has been focused. */
+  readonly current: Schema.NullOr<Schema.String>;
+  /** The rows whose open state differs from `openByDefault`. */
+  readonly toggled: Schema.$Array<Schema.String>;
+}>;
+type Model$1 = typeof Model$1.Type;
+declare const Message$1: import("foldkit/message").MessageUnion<{
+  /** A row became current: the user focused it, or a key moved there. */
+  readonly Focused: {
+    readonly id: Schema.String;
+  };
+  readonly Opened: {
+    readonly id: Schema.String;
+  };
+  readonly Closed: {
+    readonly id: Schema.String;
+  };
+}>;
+type Message$1 = typeof Message$1.Type;
+declare const Args$1: Schema.Struct<{
+  /** Whether a row with children starts open. */
+  readonly openByDefault: Schema.Boolean;
+}>;
+type Args$1 = typeof Args$1.Type;
+/** Whether a row is open, given the default and what was toggled. */
+declare const isOpen: (model: Model$1, args: Args$1, id: string) => boolean;
+declare const bundle$1: Bundle.Bundle<"TreeNavigation", {
+  readonly openByDefault: boolean;
+}, {
+  readonly current: string | null;
+  readonly toggled: readonly string[];
+}, {
+  readonly _tag: "Focused";
+  readonly id: string;
+} | {
+  readonly _tag: "Opened";
+  readonly id: string;
+} | {
+  readonly _tag: "Closed";
+  readonly id: string;
+}, never, never, never, void, {}, {}>;
+/** One row of the tree, in tree order: a parent comes before its children. */
+interface Row {
+  readonly id: string;
+  /** The parent's id, or `null` for a top-level row. */
+  readonly parent: string | null;
+  /** Whether it has children, so it can be opened and closed. */
+  readonly branch: boolean;
+  readonly disabled?: boolean;
+}
+/** A row as it is showing: where it sits, for its ARIA attributes. */
+interface Shown extends Row {
+  /** 1 for a top-level row. */
+  readonly level: number;
+  /** Its place among its siblings, from 1, and how many there are. */
+  readonly position: number;
+  readonly siblings: number;
+}
+/**
+ * The rows that are showing: every row whose ancestors are all open, with its
+ * level and its place among its siblings. A row whose parent is not a row is
+ * treated as top-level.
+ */
+declare const shown: (rows: ReadonlyArray<Row>, model: Model$1, args: Args$1) => ReadonlyArray<Shown>;
+/** What a key does: move to a row, or open or close one. */
+type Action = {
+  readonly _tag: 'Focus';
+  readonly id: string;
+} | {
+  readonly _tag: 'Open';
+  readonly id: string;
+} | {
+  readonly _tag: 'Close';
+  readonly id: string;
+};
+/**
+ * What a key does from the current row, over the rows that are showing, or
+ * `undefined` when it is not a key the tree handles. Disabled rows are stepped
+ * over. With nothing current, Down and Home land on the first row, Up and End
+ * on the last. Right and Left swap under `rtl`.
+ */
+declare const move: (rows: ReadonlyArray<Shown>, current: string | null, key: string, modifiers: KeyboardModifiers, model: Model$1, args: Args$1, direction?: "ltr" | "rtl") => Action | undefined;
+/** The row that holds the tab stop: the current one while it is showing, else the first. */
+declare const tabStop: (rows: ReadonlyArray<Shown>, current: string | null) => string | undefined;
+interface BehaviorOptions$1<Input, Slots> {
+  /** The slot that receives the keys: the element with `role="tree"`. */
+  readonly container: keyof Slots & string;
+  /** The slot rendered once per showing row, with `item.id` or `item.index` into `shown`. */
+  readonly item: keyof Slots & string;
+  /** Every row, open or not, in tree order. */
+  readonly rows: (input: Input) => ReadonlyArray<Row>;
+  /** The DOM id a row's element carries. Default: the row's own id. */
+  readonly domId?: (id: string) => string;
+  readonly direction?: (input: Input) => 'ltr' | 'rtl';
+}
+/**
+ * Wires a placed `TreeNavigation` to the slots. The container's keys move focus
+ * to the row they pick, or open or close the current row with focus left where
+ * it is. Each showing row gets its id, `role="treeitem"`, `aria-level` (and
+ * the same level as `--fk-tree-level`, so one `calc` indents any depth),
+ * `aria-posinset`, `aria-setsize`, `aria-expanded` when it has children,
+ * `aria-disabled` when disabled, a roving `tabindex`, and `OnFocus` reporting
+ * it current. Every handled key is default-prevented.
+ */
 declare const behavior$1: <Field extends string>(declared: Declared<typeof bundle$1, Field>, args: Args$1) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$1; }, ParentMessage>(options: BehaviorOptions$1<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 declare namespace typeahead_d_exports {
   export { Args, BehaviorOptions, Message, Model, behavior, bundle, isPrintable, match };
@@ -858,5 +1013,5 @@ interface BehaviorOptions<Input, Slots> {
  */
 declare const behavior: <Field extends string>(declared: Declared<typeof bundle, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model; }, ParentMessage>(options: BehaviorOptions<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
 //#endregion
-export { dismiss_layer_d_exports as DismissLayer, focus_scope_d_exports as FocusScope, focus_visible_d_exports as FocusVisible, grid_navigation_d_exports as GridNavigation, layers_d_exports as Layers, list_navigation_d_exports as ListNavigation, live_announce_d_exports as LiveAnnounce, long_press_d_exports as LongPress, move_d_exports as Move, press_d_exports as Press, roving_tabindex_d_exports as RovingTabindex, selection_d_exports as Selection, typeahead_d_exports as Typeahead };
+export { dismiss_layer_d_exports as DismissLayer, editable_text_d_exports as EditableText, focus_scope_d_exports as FocusScope, focus_visible_d_exports as FocusVisible, grid_navigation_d_exports as GridNavigation, layers_d_exports as Layers, list_navigation_d_exports as ListNavigation, live_announce_d_exports as LiveAnnounce, long_press_d_exports as LongPress, move_d_exports as Move, pointer_drag_d_exports as PointerDrag, press_d_exports as Press, roving_tabindex_d_exports as RovingTabindex, selection_d_exports as Selection, targets_d_exports as Targets, tree_navigation_d_exports as TreeNavigation, typeahead_d_exports as Typeahead };
 //# sourceMappingURL=index.d.mts.map