@vibecook/ice 0.15.0 → 0.16.0-portals.2

package/dist/types/packages/core/src/catalog/desk.d.ts

@@ -122,7 +122,10 @@ export declare const HeldPointer: import("@vibecook/strata-ecs").Component<impor
  * a tap that puts it down), on one of the kind's named PARTS (`part`, D3t-b: the kind's own — a
  * notebook's turn, its click and its drag; never a tap that puts it down) or elsewhere on the object
  * itself (`object`: two instant taps put it down). `part`: the part it began on ("" — none); `x`/`y`
- * where it began (CSS px), the pan it began from, and whether it has moved past the slop.
+ * where it began (CSS px), the pan it began from, and whether it has moved past the slop. `count`
+ * (design-019 §5, M24 LT2): its CLICK COUNT — 1, then 2, 3… for each primary press that lands within
+ * the desk's multi-tap window and slop of the one before (`HeldPressMemo`; a pointerdown's `detail`
+ * is 0 in the browser, so the desk counts — by the down events' own times); a middle press's is 1.
  */
 export declare const HeldPress: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
     readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"object" | "pan" | "part" | "desk" | "tool">, true>;
@@ -132,6 +135,7 @@ export declare const HeldPress: import("@vibecook/strata-ecs").Component<import(
     readonly panX0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
     readonly panY0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
     readonly moved: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly count: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
 }>, {
     readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"object" | "pan" | "part" | "desk" | "tool">, true>;
     readonly part: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
@@ -140,6 +144,37 @@ export declare const HeldPress: import("@vibecook/strata-ecs").Component<import(
     readonly panX0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
     readonly panY0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
     readonly moved: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly count: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
+/**
+ * The last PRIMARY press in hand (design-019 §5, M24 LT2): where it began (CSS px), when (its down event's own time — the frame's
+ * `now` for an input with none) and its click count — the next primary press within `GestureSettings.multiTapWindowMs` and
+ * `multiTapSlopPx` of it counts on (down to down, any pointer: each touch is a pointer of its own). Cleared when nothing is held.
+ */
+export declare const HeldPressMemo: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly at: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly count: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly at: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly count: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
+/**
+ * Runtime, on a local pointer while an object is held whose kind takes the WHEEL (`OpenBinding.wheel: "kind"` — design-019 §5, M24
+ * LT2): the plain wheel's deltas of the last tick that had any, CSS px of the hand, and `seq` — moved once per such tick, so the
+ * desk tells the kind each tick's wheel once (`HeldEvent` "wheel"). ⌘/ctrl-wheel and the pinch stay the hand's (they zoom it).
+ */
+export declare const HeldWheel: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly dx: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly seq: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly dx: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly seq: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
 }>;
 /** The last instant tap on the held object: where and when — a second within the window puts it down (the notebook's case, generalised). */
 export declare const HeldTapMemo: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{

package/dist/types/packages/core/src/catalog/selection-presence.d.ts

@@ -19,16 +19,6 @@ export declare const SweepsContained: import("@vibecook/strata-ecs").Tag;
  * behaviour to read (systems/press-wheel.ts).
  */
 export declare const WheelTurns: import("@vibecook/strata-ecs").Tag;
-/**
- * `interaction.keyboard: "exclusive"` (design-007 §3.1, petitions I1/I4): while
- * a node inside this widget holds browser focus, the engine's keyboard surfaces
- * (keymap shortcuts, the adapter's Space pan modifier) stand down. The ROUTING
- * truth is the DOM — the dom-widgets reflector writes a `data-canvas-keyboard`
- * marker on the widget host and the keymap/adapter read the event-target chain
- * against `document.activeElement`; this tag is the ECS-side mirror of the
- * declaration (queryable by devtools/presence), never a routing input.
- */
-export declare const KeyboardExclusive: import("@vibecook/strata-ecs").Tag;
 /**
  * Marks an ephemeral presence-peer entity (design-001 §5.6). Rides the presence
  * blob so remote peers project it — a peer query is `[PresencePeer, Not(Local)]`

package/dist/types/packages/core/src/systems/held.d.ts

@@ -28,11 +28,16 @@
  *    PARTS (D3t-b: any part but `content` and `frame`, the object itself): that press is the KIND's
  *    (`HeldPress` `part`, with the part it began on — a notebook's turn: two clicks there turn two pages);
  *  - every route above is the PRIMARY button's (petition I28, press-button.ts): a secondary press — and a middle one with nothing
- *    to pan — is a point in the hand as on the desk: it keeps no `HeldPress`, so it puts nothing down, works no part, lays no stroke.
+ *    to pan — is a point in the hand as on the desk: it keeps no `HeldPress`, so it puts nothing down, works no part, lays no stroke;
+ *  - (design-019 §5, M24 LT2) a primary press is COUNTED — `HeldPress.count`, 1, 2, 3… within the multi-tap window and slop of the
+ *    last (`HeldPressMemo`, by the down events' own times): the platform's `detail` is 0 on a pointerdown, so the desk counts; and a
+ *    kind that takes the wheel (`OpenBinding.wheel: "kind"` — its type's `heldWheel`) has a plain wheel written to `HeldWheel` for it
+ *    instead of panning the hand — ⌘/ctrl and the pinch zoom the hand as ever, and past 0.72× still put it down.
  * The ways back are OPS (`ops.putDown`, structural) and a system may not run them mid-tick: it writes
  * the one-tick `HeldIntent` and the facade applies it after the step (D2b's `NavIntent`, same shape).
  * Nothing here reads a kind: the seam gives a frame and (D3t-a) the part under a point; the tool in
- * hand is core's `HeldTool`.
+ * hand is core's `HeldTool`, the wheel's owner the widget type's `heldWheel`. The kind is TOLD its input by the desk, which folds
+ * `HeldPointer`, `HeldPress` and `HeldWheel` into its `held` events (desk/hold/told.ts) — never a second input path.
  */
 import type { Entity, System, World } from "@vibecook/strata-ecs";
 /** The held object's frame ON SCREEN as the renderer drew it this frame (CSS px): its centre, half extents, its scale (CSS px per object unit), and whether the pickup has settled (the wheel waits for it). */
@@ -47,11 +52,13 @@ export interface HeldScreenFrame {
 /**
  * The pose seam: the renderer's word on where the held object is — `undefined` before its first frame — and (D3t-a) which of
  * its kind's parts is under a point of the object's own frame (its `hit` on the geometry it drew: the board's melamine
- * `content`, its `frame`), null over nothing; absent = no parts ("content" inside the frame).
+ * `content`, its `frame`), null over nothing; absent = no parts ("content" inside the frame). `cursor` (design-019 §5, M24 LT2):
+ * the kind's cursor over one of its NAMED parts (its `open.cursor`) — L4 shows it above its own; undefined: L4's.
  */
 export interface HeldPoseSource {
     frame(entity: Entity): HeldScreenFrame | undefined;
     part?(entity: Entity, x: number, y: number): string | null;
+    cursor?(entity: Entity, part: string): string | undefined;
 }
 /** The stack's slot for the pose source — a mutable box, so the renderer can arrive after install (as `framePick`). */
 export interface HeldPoseSlot {

package/dist/types/packages/core/src/systems/l4-cursor.d.ts

@@ -12,7 +12,10 @@
  * everything but the hand's. (design-018 §5: the lip's "pointer" retired with its handle — the drawer's handle is the app's DOM bar.)
  * Above all of them (design-015 §8, D3t-a): with an object IN HAND, the mode in hand's own
  * `cursor` (its `HeldToolDef.cursor` — "none" where the tool draws itself: the board's marker) while
- * the mouse is over the object's drawing surface (`HeldPointer.part` "content") or presses the tool.
+ * the mouse is over the object's drawing surface (`HeldPointer.part` "content") or presses the tool —
+ * and (design-019 §5, M24 LT2) over one of the kind's NAMED parts, the KIND's cursor when it names one:
+ * the pose seam's `cursor` (its `open.cursor` — a link's `pointer`, a text field's `text`), asked each
+ * run while the mouse is over such a part; undefined there falls to the rest, as ever.
  *
  * Scheduled on the `CanvasSurface` anchor query (exactly one such entity,
  * guaranteed by install — the same idiom `pointerIngest` uses in l0-input.ts)
@@ -24,6 +27,10 @@
  * cursor reflector is the only consumer (core never touches DOM).
  */
 import type { System, World } from "@vibecook/strata-ecs";
-export declare function createCursorSync(world: World): System & {
+import type { HeldPoseSlot } from "./held";
+/** `pose`: the stack's held pose slot (`installInteractionStack`'s `heldPose`) — the kind's cursor in hand rides it (M24 LT2). */
+export declare function createCursorSync(world: World, opts?: {
+    readonly pose?: HeldPoseSlot;
+}): System & {
     readCursor(): string;
 };

package/dist/types/packages/core/src/widget/define-widget.d.ts

@@ -113,24 +113,6 @@ export interface WidgetInteraction {
      * that pointer is the widget's, never the camera's; its deltas add up in the pointer's `PressWheel`. Default false.
      */
     readonly wheelTurns?: boolean;
-    /**
-     * Keyboard claim (design-007 §3.1, petitions I1/I4). `"exclusive"`: while a
-     * node inside this widget's claim holds browser focus, the engine keymap and
-     * the adapter's Space pan modifier stand down — keys flow to the widget's own
-     * handlers (the engine stops competing; it never delivers behavior). The claim
-     * is a `data-canvas-keyboard` host in screen space (the desk's one focused
-     * editor carries it), and plain wheel over its scrollable content cedes to
-     * native scroll (ctrl/pinch stays canvas zoom always). Default `"shared"`.
-     */
-    readonly keyboard?: "shared" | "exclusive";
-    /**
-     * Escape ownership under an exclusive claim (design-007 §3.3 / §7-Q1).
-     * `"release"` (default): Escape is the engine-reserved release gesture — it
-     * blurs the widget; the NEXT Escape, with focus gone, cancels gestures.
-     * `"widget"`: even Escape flows to the widget (vim-grade terminals); release
-     * is click-away or `blurFocus()`. Ignored unless `keyboard: "exclusive"`.
-     */
-    readonly keyboardEscape?: "release" | "widget";
 }
 export interface WidgetDef {
     readonly type: string;
@@ -174,6 +156,18 @@ export interface WidgetDef {
     readonly heldTools?: readonly HeldToolDef[];
     /** The mode in hand when the object is picked up, from its props (the board: its capped marker's ink). Default: the first mode, else none. */
     readonly heldTool?: (props: Readonly<Record<string, unknown>>) => string;
+    /**
+     * The WHEEL in hand (design-019 §5, M24 LT2 — the desk's `defineObject` passes its kind's `open.wheel`): `"hand"` (the default — a
+     * plain wheel moves the object once brought close) or `"kind"` — a plain wheel is the kind's (core writes it to the pointer's
+     * `HeldWheel`, the desk tells the kind); ⌘/ctrl-wheel and the pinch zoom the hand either way. Refused on anything that does not open.
+     */
+    readonly heldWheel?: "hand" | "kind";
+    /**
+     * ESCAPE in hand (design-019 §5, M24 LT2 — the kind's `open.escape`): `"desk"` (the default — Esc puts the object down) or `"kind"` —
+     * Esc is the kind's (a source that owns it: a terminal), and the keymap never puts the object down for it: Done, a click off it or
+     * the pinch do. Refused on anything that does not open.
+     */
+    readonly heldEscape?: "desk" | "kind";
     /**
      * The acts the SELECTION MENU offers for a selection of this type's objects (design-016 §5 · K-L2, K8a — widget/menu-actions.ts):
      * each an id, a label, a glyph and an op; the menu shows one when every selected object's type declares it, and
@@ -325,10 +319,10 @@ export interface WidgetType {
     readonly provides: readonly string[];
     /** Fixed nested-frame binding and ingress/portal metadata, when a container. */
     readonly container: WidgetContainerEntry | undefined;
-    /** Keyboard claim (design-007): the dom layer reads THIS (registry truth), not the tag. */
-    readonly keyboard: "shared" | "exclusive";
-    /** Escape ownership under an exclusive claim ("release" = engine-reserved). */
-    readonly keyboardEscape: "release" | "widget";
+    /** The plain wheel's owner in hand (M24 LT2): `"hand"` unless the object's kind takes it — core's held input reads THIS. */
+    readonly heldWheel: "hand" | "kind";
+    /** Escape's owner in hand (M24 LT2): `"desk"` unless the object's kind owns it — the keymap reads THIS. */
+    readonly heldEscape: "desk" | "kind";
     /** May instances be dropped INTO an accepting container (design-015 §9; `"never"` = a root object always, D-D18)? The drop system reads THIS. */
     readonly drop: "into" | "never";
     readonly migrate: Readonly<Record<number, (prev: Record<string, unknown>) => Record<string, unknown>>>;

package/dist/types/packages/desk/src/hold/told.d.ts

@@ -0,0 +1,15 @@
+import { type Entity, type World } from "../../../core/src/index";
+import type { HeldEvent } from "../kinds/world";
+/** One object's events for one frame. */
+export interface HeldTold {
+    readonly entity: Entity;
+    readonly events: readonly HeldEvent[];
+}
+export interface HeldFold {
+    /**
+     * This frame's events — for the object in hand when something happened, and for the object the hand just LET GO of when a press of
+     * its kind was still down (its `up`, where the pointer was last). Empty when nothing happened or nothing is held.
+     */
+    step(): readonly HeldTold[];
+}
+export declare function createHeldFold(world: World): HeldFold;

package/dist/types/packages/desk/src/index.d.ts

@@ -4,7 +4,7 @@ export * from "./host/index";
 export * from "./compose/index";
 export * from "./kit/index";
 export * from "./object";
-export { type DataChildren, FLUX_REST, type HeldContext, type HeldReadoutContext, type HeldToolDef, type InsideContext, isObjectKind, type KindDriver, type KindDriverHost, type KindHost, type KindLocal, numberProp, type ObjectContext, type ObjectDomHost, type ObjectFlux, type ObjectHit, type ObjectHost, type ObjectKind, type ObjectRect, type OpenBinding, rectFrame, rectOf, type RungContext, type StratumName, stringProp } from "./kinds/world";
+export { type DataChildren, FLUX_REST, type HeldContext, type HeldCursorContext, type HeldEvent, type HeldReadoutContext, type HeldToolDef, type InsideContext, isObjectKind, type KindDriver, type KindDriverHost, type KindHost, type KindLocal, numberProp, type ObjectContext, type ObjectDomHost, type ObjectFlux, type ObjectHit, type ObjectHost, type ObjectKind, type ObjectRect, type OpenBinding, rectFrame, rectOf, type RungContext, type StratumName, stringProp } from "./kinds/world";
 export { carryOf, focusOf, HELD_USER_REST, type HeldPose, type HeldUser, type HeldViewport, heldCamera, heldFrame, heldPose, HOLD, type HoldOptions, type HoldReserves, type HomePose, homePose, isNarrow, type ReadingTarget, readingTarget } from "./hold/pose";
 export { NO_DOCS, type TypingDocs, type WritableSession, writable } from "./docs";
 export { createKindFaults, faultText, KIND_MISSING, KIND_STRIKES, type KindFault, type KindFaults } from "./faults";

package/dist/types/packages/desk/src/kind.d.ts

@@ -87,7 +87,11 @@ export interface KindPass<R = unknown> {
      * its own before the frame's, as the whiteboard's stamps and drying do). Returns the count that will draw.
      */
     prepare(encoder: GPUCommandEncoder, slot: SlotContext, records: readonly R[], extra?: KindExtra): number;
-    /** Draw records [first, end) — indices into this frame's `records` — in their order, into the open pass. */
+    /**
+     * Draw records [first, end) — indices into this frame's `records` — in their order, into the open pass: with as many of the kind's
+     * own pipelines as it draws them with (a LIGHT pipeline multiplies what lies below the run, and nothing in the hand target — the
+     * header's light pass).
+     */
     drawRange(pass: GPURenderPassEncoder, first: number, end: number): void;
     /**
      * The kind's persistent record store's counters (design-015 §4.3; D6) — records packed and uploaded, draw lists rewritten — a

package/dist/types/packages/desk/src/kinds/world.d.ts

@@ -61,6 +61,43 @@ export type { HeldToolDef } from "../../../core/src/index";
 export interface HeldReadoutContext extends Pick<HeldToolApi, "world" | "entity" | "props"> {
     readonly local: unknown;
 }
+/** What a kind's `open.cursor` reads (design-019 §5, M24 LT2): the object in hand, the NAMED part under the mouse, the kind's state on this desk. */
+export interface HeldCursorContext {
+    readonly entity: Entity;
+    readonly part: string;
+    readonly local: unknown;
+}
+/**
+ * One thing the HAND did with the object in hand, TOLD to its kind (design-019 §5, M24 LT2 — `KindLocal.held`), in the held extent's
+ * own units, centred (as core's `HeldPointer` is: the open extent, through the pose the renderer drew). A kind reaches the desk through
+ * `/desk`, `/desk/kit` and `/desk/engine` alone, so it is TOLD its input — it never reads core's pointer components.
+ * - `pointer`: the `down`, each frame's `move` (one sample a frame — the ingest folds a frame's moves) and the `up` of a press ON the
+ *   object — on one of the kind's named parts (the kind's own: never a tap that puts it down), on its `content` or `frame` (two instant
+ *   taps there still put it down — the hand's rule), with a mode in hand on its surface — and the pointer's moves between presses, over
+ *   the object or off it. `part`: the kind's own `hit` under it (null over nothing); `button` the one pressed or released (0 — a press in
+ *   hand is the primary's, petition I28; −1 on a move); `buttons` the mask held (a primary press's never empty); `count` the press's
+ *   click count (core's `HeldPress.count`: 1, 2, 3… within the desk's multi-tap window and slop; 0 on a move). A press the HAND takes —
+ *   a pan (the middle button, Space), a press on the soft desk — is never told, nor its moves; a press of the kind's still down when the
+ *   hand lets go is told its `up` where the pointer was last.
+ * - `wheel`: a plain wheel while the object is in hand and its kind takes the wheel (`OpenBinding.wheel: "kind"`) — the frame's deltas, CSS
+ *   px of the hand, at the pointer's point over the object or off it (the kind decides what lands on it).
+ */
+export type HeldEvent = {
+    readonly type: "pointer";
+    readonly phase: "down" | "move" | "up";
+    readonly x: number;
+    readonly y: number;
+    readonly part: ObjectHit | null;
+    readonly button: number;
+    readonly buttons: number;
+    readonly count: number;
+} | {
+    readonly type: "wheel";
+    readonly x: number;
+    readonly y: number;
+    readonly dx: number;
+    readonly dy: number;
+};
 /**
  * The kind's OPENING (design-015 §8; D4b) — what "pick it up" means for this kind. `extent`: the OPEN rect in the object's
  * own desk units, centred as its rect is and UNTURNED (the builder turns it with the object): a notebook's spread (twice the
@@ -93,6 +130,27 @@ export interface OpenBinding {
      * word draws nothing of the desk).
      */
     readonly readout?: string | ((ctx: HeldReadoutContext) => string | undefined);
+    /**
+     * The WHEEL in hand (design-019 §5, M24 LT2): `"hand"` (the default — a plain wheel moves the object once brought close) or `"kind"`
+     * — a plain wheel while it is held is the kind's, told as a `HeldEvent` "wheel" with its point (a page scrolls); the hand never pans
+     * for it. ⌘-wheel and the pinch still zoom the hand, and past 0.72× still put it down. Carried onto the widget type (`heldWheel`) by
+     * `defineObject`, where core's held input reads it.
+     */
+    readonly wheel?: "hand" | "kind";
+    /**
+     * The CURSOR in hand (design-019 §5, M24 LT2): asked while the object is held and the mouse is over one of the kind's NAMED parts
+     * (any but `content` and `frame`) — a link's `pointer`, a text field's `text`, from what its source says (`LiveInfo.cursor`); the
+     * desk shows it above its own (core's L4), written to the container only when it changes. `undefined` or "": the desk's own. One
+     * that throws is a strike against the kind (petition I24) and the desk's own is shown.
+     */
+    cursor?(ctx: HeldCursorContext): string | undefined;
+    /**
+     * ESCAPE in hand (design-019 §5, M24 LT2): `"desk"` (the default — Esc puts the object down, in one press even while its kind leases
+     * the editor) or `"kind"` — Esc is the kind's (a source that owns it: a terminal; its lease takes the key): the keymap never puts the
+     * object down for it nor blurs the editor, and the hand is put down by Done, a click off it, or the pinch. Carried onto the widget
+     * type (`heldEscape`) by `defineObject`, where the keymap reads it.
+     */
+    readonly escape?: "desk" | "kind";
 }
 /**
  * What the builder hands the object IN HAND (D4b, beside its flux): the carry amount `e` (0 on the desk … 1 in hand — the
@@ -154,8 +212,9 @@ export interface KindHost {
      * decoder `PICTURE_DECODER`, the app's byte store `BLOB_STORE`, anything in `deskLayer({ services })`) and what any object's DOM
      * half lends (`ObjectHost.lend` — the desk calendar's `PRINT_RASTER`): `use(key)` answers it, or undefined when nothing on this
      * desk lends it (in Node the oracle pins committed rasters and tiles). Absent: a bare host (a test) — no services at all.
-     * D-K8a.1: the desk's OWN doors stay fields of this host — `pass`, `children`, `drawn`, `budget`, `rasters`, `remake`, `wake`: the
-     * builder's word, its budget, its queue and its loop, made by the desk for each kind and never lent, replaced or taken by a kind.
+     * D-K8a.1: the desk's OWN doors stay fields of this host — `pass`, `children`, `drawn`, `budget`, `rasters`, `remake`, `wake`,
+     * `redraw`, `keyOf`, `frames`: the builder's word, its budget, its queue, its loop and the document's keys, made by the desk for each
+     * kind and never lent, replaced or taken by a kind.
      */
     use?<T>(key: ServiceKey<T>): T | undefined;
     /** An object's DATA children (D3w, design-015 §5.1 — a board's strokes, a pad's events and pins); absent = none (a test, the oracle). */
@@ -186,6 +245,31 @@ export interface KindHost {
      * kind never polls for what an arrival can tell it. Absent (a bare host, the oracle): its tick is asked every frame.
      */
     readonly wake?: (() => void) | undefined;
+    /**
+     * DRAW AGAIN, REMAKE NOTHING (design-019 §3.3, M24 LT1): the next frame is encoded again and no record is remade — what a kind
+     * asks when something its pass reads changed under records that stand (a live face's texture took a frame: `LiveFace.take`
+     * answered true). Called in the kind's tick (whose answer is then FALSE — true would remake every record of the kind) or from
+     * outside a frame; either way the frame is drawn and a sleeping loop wakes for it — the reflector dirtied as a driver's and a DOM
+     * half's `wake` dirty it. Absent (a bare host): nothing to draw; a still's (`createStill`) does nothing — its one frame follows.
+     */
+    readonly redraw?: (() => void) | undefined;
+    /**
+     * THE OBJECT'S DURABLE KEY (design-019 §3.5, M24 LT1): strata's durable entity key (`DurableStore.keyOf`, strata §14.3) — minted
+     * ONCE for the entity by the peer whose transaction made it (`<peer>-<n>`: a peer's counter resumes past its own keys, so a key
+     * is never minted twice) and carried in the document as the entity's own key, so every peer projects the entity under it and a
+     * reload binds it to its new runtime handle: the same on every peer and across reloads, where the `Entity` is neither. A host
+     * names an outside surface by it (a page re-attached on reload, not restarted). Undefined for a runtime-only entity (a tray's
+     * insert ghost, a specimen) and with no document. Absent (a bare host): none known.
+     */
+    readonly keyOf?: ((e: Entity) => string | undefined) | undefined;
+    /**
+     * THE DESK'S FRAMES (design-019 §3.4, M24 LT1): how many frames this desk has drawn — the reflector's count
+     * (`DeskLayerHandle.redraws()`), moving once per frame drawn and never for a capture. A kind with no records in a slot is never
+     * prepared, and a kind is ticked on steps that draw nothing (an input step), so "my pass was not asked" means "not drawn" only when
+     * a frame WAS drawn: what a kind that folds its prepares per frame reads for that boundary (`createSight(host.frames)`). Absent (a
+     * bare host, a still): every step is taken as a frame.
+     */
+    readonly frames?: (() => number) | undefined;
 }
 /**
  * An object's DATA children as its kind reads them (D3w): entities `ChildOf` the object, never members of the desk's
@@ -240,6 +324,13 @@ export interface KindLocal {
     veils?(): ReadonlySet<Entity>;
     /** The kind's word on a raster it charged to the budget (D6): true = on screen this frame, never evicted now. */
     keeps?(key: string): boolean;
+    /**
+     * The HAND's input while `e` is IN HAND (design-019 §5, M24 LT2 — `HeldEvent`): called once a frame something happened, after the
+     * drivers and before the kinds' ticks, with the frame's events in order. The desk derives them from what core writes (`HeldPointer`,
+     * `HeldPress`, `HeldWheel`) — never a second input path — so a kind's DOM half and its world half see one hand. A kind that keeps a
+     * driver of its own (the calendar's hand) may read core's facts instead. One that throws is a strike against the kind (petition I24).
+     */
+    held?(e: Entity, events: readonly HeldEvent[]): void;
     dispose?(): void;
 }
 /** What a kind's `rung` reads (K6b): the object as the builder holds it, its SLOT's zoom (an inside's is its host's face's) and the dpr, and its kind's state on this desk. */

package/dist/types/packages/desk/src/kit/editor.d.ts

@@ -39,8 +39,16 @@ export interface EditorLease {
      * (a peer's, an undo) reaches the platform's field; `null`: keep the field's own (a session is open — the field is the truth).
      */
     value(): string | null;
-    /** The platform's value after an input event. */
+    /** The platform's value after an input event (while a composition runs, only for a lease that declares no `compose`). */
     input(value: string): void;
+    /**
+     * The IME's COMPOSITION as it runs (design-019 §5, M24 LT2 — the preedit a remote page's IME is driven by): told once as it starts
+     * (`""`, 0) and after each update the platform applies — the composition's text and the caret within it. A lease that declares it is
+     * told the composition INSTEAD of `input` values while one runs; absent, it sees the field's values as ever (the preedit inside them).
+     */
+    compose?(text: string, caret: number): void;
+    /** The composition COMMITTED (`compositionend`'s data, M24 LT2) — the text it ended with ("" when it was cancelled). */
+    commit?(text: string): void;
     /** A key the lease takes: true — handled (the editor prevents its default, so the keymap stands down). */
     keydown(ev: KeyboardEvent): boolean;
     /** The caret moved (a selection change, a tap, a value the world moved): its index. */

package/dist/types/packages/desk/src/kit/index.d.ts

@@ -7,6 +7,7 @@ export * from "./hold";
 export * from "./inside";
 export * from "./layer";
 export * from "./light";
+export * from "./live";
 export * from "./mesh";
 export * from "./mips";
 export * from "./nav";