@vibecook/ice 0.11.0 → 0.15.0-desk.1

package/dist/types/packages/core/src/surface/gpu-device.d.ts

@@ -0,0 +1,55 @@
+/**
+ * THE ENGINE'S DEVICE (design-012 §4 "Device"; kept as the device door at design-015 D5b, slimmed at D7): ONE device
+ * per engine. An app that wants the device before the desk mounts — to read its uncaptured errors, to share it with
+ * work of its own — acquires it here and passes it to `createCanvasEngine({ compositorDevice })`; the desk's layer then
+ * DRAWS WITH IT (`createDeskHost` hands it through the layer context) instead of acquiring a device of its own, so
+ * `errors()` sees the desk's uncaptured GPU errors. Absent — the common case, and every headless engine — the desk
+ * acquires its own. The engine never destroys it: the app that acquired it owns its end of life.
+ *
+ * The error log subscribes with `addEventListener('uncapturederror')`, never the `onuncapturederror` property, so no
+ * other holder of the device can disconnect it; it is armed HERE, before any consumer exists, so no error goes unseen.
+ * (The three.js creation rules this module carried for the GL islands — no compatibility adapter, every advertised
+ * feature — left with three at D7; `hasCoreFeatures`, three's compatibility-mode signal, with them.) ONE feature is asked
+ * for whenever the adapter has it (design-016 §4, K2): `timestamp-query`, the GPU profiler's clock — a feature cannot be
+ * added to a device once it is made, and one left unused costs nothing, so every engine's device can be profiled.
+ *
+ * Headless-safe: WebGPU is not DOM (it exists in workers), so naming it here does not breach core's wall. The only
+ * environmental touch is reading `navigator.gpu`, and its absence is a clean typed failure, never a throw from deep
+ * inside a layer. TYPES: `@webgpu/types` is the ONE entry in `tsconfig.base.json`'s `types` array, and a runtime-free
+ * dependency of `@vibecook/ice`, so the published `.d.ts` resolves for consumers.
+ */
+export interface GpuUncapturedError {
+    /** `performance.now()` at capture, or 0 where the clock is unavailable. */
+    readonly at: number;
+    readonly type: string;
+    readonly message: string;
+}
+/** The engine's GPU facts. Reached as `engine.compositorDevice` — undefined unless the app passed one (the desk then acquires its own). */
+export interface EngineGpu {
+    readonly adapter: GPUAdapter;
+    readonly device: GPUDevice;
+    /** Features actually enabled on the device (not merely adapter-advertised). */
+    readonly enabled: readonly string[];
+    /** `timestamp-query` is on the device — asked for whenever the adapter has it (the GPU profiler's clock, design-016 §4). */
+    readonly hasTimestampQuery: boolean;
+    /** Uncaptured GPU errors since acquisition, newest last. */
+    errors(): readonly GpuUncapturedError[];
+    /** Release the device. The ENGINE NEVER CALLS THIS — nor does the desk's layer that drew with it: the app that acquired it owns its end of life. */
+    destroy(): void;
+}
+export interface AcquireDeviceOpts {
+    /** Defaults to "high-performance" — the desk is the frame's fill cost. */
+    readonly powerPreference?: GPUPowerPreference;
+    /** Features to enable where the adapter has them, beside `timestamp-query` (always asked for where the adapter has it; the desk's drawing needs none). */
+    readonly requiredFeatures?: readonly GPUFeatureName[];
+    /** Cap the retained error log (defaults to 64). */
+    readonly maxErrors?: number;
+}
+export declare class GpuUnavailableError extends Error {
+    constructor(message: string);
+}
+/**
+ * Acquire the engine's device. Called by the APP before `createCanvasEngine({ compositorDevice })`; the desk's layer
+ * receives it from there. Throws {@link GpuUnavailableError} rather than returning a half-state.
+ */
+export declare function acquireCompositorDevice(opts?: AcquireDeviceOpts): Promise<EngineGpu>;

package/dist/types/packages/core/src/systems/camera-sim.d.ts

@@ -11,6 +11,35 @@ export declare const CameraInertia: import("@vibecook/strata-ecs").Resource<impo
     readonly vx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly vy: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
 }>;
+/**
+ * This frame's WHEEL zoom (design-015 §9, D2a-core): the one-tick fact a system
+ * that runs after `cameraControl` reads to know "this frame zoomed in / out
+ * about this anchor" — D2b's zoom-through is the first. `cameraControl` is its
+ * one writer, change-only: it writes a step on each frame whose wheel zoom (a
+ * plain wheel in `"zoom"` mode, or a pinch-wheel in either mode) moved the
+ * zoom, and resets `ratio` to 1 on the first frame after that has none; idle
+ * frames write nothing.
+ *  - `ratio`: zoom after ÷ zoom before, over this frame's wheel zooms — `> 1`
+ *    zoomed in, `< 1` out, `1` no step (a clamped zoom is no step).
+ *  - `anchorX/Y`: the screen point (CSS px) of the frame's last wheel zoom.
+ *  - `tick`: the `FrameInfo.tick` it happened on, for a reader that runs BEFORE
+ *    `cameraControl` and must tell last frame's step from this one's.
+ * Not recorded: pans, flights, ops (`zoomTo`, fits) and the TOUCH pinch — whose
+ * zoom is absolute from its own start (`startZoom · spread/startDist`), so a
+ * consumer that re-bases the camera mid-pinch would have to re-base the pinch
+ * too; that is the consumer's call to make, not a fact to hand it silently.
+ */
+export declare const WheelZoomStep: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly ratio: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly anchorX: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorY: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly tick: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly ratio: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly anchorX: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorY: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly tick: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
 export interface CameraSystems {
     cameraControl: TickSystem;
     cameraInertia: TickSystem;

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

@@ -3,14 +3,11 @@
  *
  * Two systems, both derive-scheduled, both write change-only:
  *
- * `selectionChrome` — maintains POOLED chrome entities mirroring the current
- *   `Selected` set: ONE selection-box entity + 8 resize-handle entities. The box
- *   entity carries ONLY the `SelectionBox` value (x,y,w,h = the union bbox); the
- *   handles carry Position + Size + `HandleSpec{anchor}` + `VisualOf → box`.
- *   Box policy (amended 2026-07-17): all-resizable selections get box + grips
- *   (v1 parity); a MULTI-selection gets the box (group bbox) even when
- *   non-resizable; a single non-resizable widget gets no engine chrome (the
- *   app owns its selection look).
+ * `selectionChrome` — maintains the POOLED resize-handle entities mirroring the
+ *   current `Selected` set: 8 handles carrying Position + Size + `HandleSpec{anchor}`,
+ *   placed about the selection's union bbox. They exist only when EVERY selected
+ *   entity is Resizable and none is taped (Locked) — v1 parity; any other
+ *   selection gets no engine chrome (the desk's marks draw its look).
  *
  *   HANDLE PICKING (the point of the design): handles carry a world AABB, so the
  *   `react`-phase `spatialSync` indexes them automatically and `picking` resolves
@@ -21,26 +18,21 @@
  *   so its on-screen hit target stays ~constant across zoom. The tradeoff: the
  *   handles must be recomputed whenever the camera zoom changes, so this system
  *   runs every frame a selection exists and rewrites the 8 handles' Position/Size
- *   change-only (a zoom change restamps 8 entities — small, bounded N; §5's
- *   "screen-space, recomputed on camera dirt, small N").
+ *   change-only (a zoom change restamps 8 entities — small, bounded N).
  *
- *   THE BOX IS DELIBERATELY NOT PICKABLE. It stores its rect in the `SelectionBox`
- *   value, NOT in Position/Size, so `spatialSync` (which indexes [Position,Size])
- *   never sees it. design-003 §3's pick priority lists ONLY HandleSpec chrome as
- *   pickable; indexing the box would make it a widget-class pick (it has Position)
- *   and let a center-of-selection click be grabbed by `moveClaim`. (This diverges
- *   from a literal reading of the M6 brief's "Position+Size+SelectionBox" — the
- *   box's geometry lives on the `SelectionBox` value instead; the chrome reflector
- *   reads it from there.)
+ *   THE SELECTION BOX LEFT AT design-015 D7: the pooled box entity carried the
+ *   union bbox in a `SelectionBox` value (with a `VisualOf` edge from each handle)
+ *   for the P4 DOM chrome that drew it; that chrome was deleted at D5b, nothing read
+ *   the box, and it was rewritten every frame the union moved (every drag frame).
+ *   Only what picking reads stays.
  *
- *   POOL LIFECYCLE: entities spawn once via `ctx` (runtime prefab class) when a
- *   selection appears and are reaped via `ctx.destroy` when it empties. On the
- *   spawn frame the handles are still identity-only (placement defers to the
+ *   POOL LIFECYCLE: the handles spawn once via `ctx` (runtime prefab class) when a
+ *   resizable selection appears and are reaped via `ctx.destroy` when it empties.
+ *   On the spawn frame they are still identity-only (placement defers to the
  *   phase boundary), so their initial geometry rides the `ctx.spawn` payload and
  *   the change-only `edit().set` updates begin the next frame.
  *
- * `breakpoint` — `WidgetBreakpoint{tier,w,h}` from a widget's EFFECTIVE size
- *   (`MeasuredSize` where auto-sized and >0, else `Size`), width-thresholded into
+ * `breakpoint` — `WidgetBreakpoint{tier,w,h}` from a widget's `Size`, width-thresholded into
  *   5 tiers with ±10% boundary hysteresis. Added lazily (on `WidgetEquipped`
  *   widgets, once measured) and thereafter written ONLY when the tier changes —
  *   the LOD signal must be stable within a tier so the measure→tier→content→

package/dist/types/packages/core/src/systems/drag-mods.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The desk's drag modifiers (design-015 §7, *Marks on the Mat*'s keys; D4a) — read off the recognizer's
+ * WATCHED pointer, whose `PointerMods` is the pointer's latched sample (design-003 §4.5; the keyboard
+ * carries only key events), so a modifier pressed or let go mid-drag takes effect on the next frame:
+ *
+ *   - ⇧ locks the drag to ONE axis — its dominant one, recomputed from the total each frame (the page's
+ *     `if (|dx| > |dy|) dy = 0 else dx = 0`); the snap then corrects only along the free axis.
+ *   - ⌘ (or Ctrl) held holds the snap off.
+ *   - ⌥ as the drag STARTS leaves a copy behind (moveClaim latches it as `LeavesCopy` on the recognizer;
+ *     the release commits the copies with the move — one gesture, one undo step).
+ *
+ * Shared by the snap system and the move behavior, so the delta the snap aligns is the delta the move
+ * writes. Pure over the ctx: no writes.
+ */
+import type { Entity, SystemCtx } from "@vibecook/strata-ecs";
+export interface DragMods {
+    readonly shift: boolean;
+    readonly alt: boolean;
+    readonly meta: boolean;
+    readonly ctrl: boolean;
+}
+/** The recognizer's watched pointer's modifiers now (none when it watches no pointer). */
+export declare function watchedMods(ctx: Pick<SystemCtx, "getRelations" | "get">, rec: Entity): DragMods;
+/** ⌘ or Ctrl held: the snap stands down for this frame. */
+export declare const snapHeldOff: (mods: DragMods) => boolean;
+/**
+ * A move drag's WORLD delta: the screen total over the zoom at its claim, locked to its dominant axis while ⇧ is
+ * held. `lock` names the axis it runs along (`x` = horizontally, its y held), null when free.
+ */
+export declare function moveDelta(ctx: Pick<SystemCtx, "read" | "getRelations" | "get">, rec: Entity): {
+    readonly x: number;
+    readonly y: number;
+    readonly lock: "x" | "y" | null;
+};

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

@@ -0,0 +1,73 @@
+/**
+ * HELD INPUT (design-015 §8; D4b) — while an object is in the hand, every pointer is the held
+ * object's and the desk behind it is inert. The HEAD of the `react` phase: the ingest's one-tick
+ * tags are flushed by then (a press is visible), and what this stamps flushes before `ctl`.
+ *
+ * The desk goes inert with the vocabulary the stack already honours: every local pointer gets the
+ * one-tick `HandledByWidget` (picking and the recognizers skip it — no hit, no tap, no drag, no
+ * selection change) and `WheelHandled` (both wheel consumers skip it — the camera never moves), the
+ * cleanup phase clears them, this system stamps them again next tick. So "no camera move" is not a
+ * rule the camera keeps; it is a fact the camera never hears about.
+ *
+ * What the pointer does instead is mapped through the SAME pose the renderer drew — the seam
+ * `HeldPoseSlot` beside `framePick`: the renderer publishes the held object's screen frame each
+ * frame (`HeldPoseSource.frame`), and a pointer's point becomes `HeldPointer` — the object's own
+ * units, centred — and an inside/outside verdict. The routes (desk.js `heldDown`/`heldMove`/
+ * `heldUp`/`heldZoomAt`/`heldPanBy`, number for number):
+ *  - a ⌘/ctrl-wheel or a pinch brings the object closer ABOUT THE POINTER (`HeldView.zoom`, up to 3×,
+ *    the pan following so the point under the pointer stays), never the mat; in past 0.72× it is put
+ *    down — and the rest of that gesture is MUTED (`HeldMute`: 400 ms, +250 per swallowed event), so
+ *    the wheel's tail never zooms the desk (the v2 lesson);
+ *  - once brought close (zoom > 1) a plain wheel moves the object under the eye, clamped so it never
+ *    leaves the middle of the view; a middle-button or Space drag pans the same way, as does a drag
+ *    that starts on the soft desk;
+ *  - a click on the soft desk — pressed and released outside the object, unmoved — puts it down; two
+ *    instant taps on the object do too (the notebook's case rule, generalised) — unless they land on its
+ *    drawing surface with a mode in hand (D3t-a): that press is the TOOL's (`HeldPress` `tool` — the
+ *    board's stroke; a double-click there is two dots, never a way back) — or on one of the kind's named
+ *    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.
+ * 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`.
+ */
+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). */
+export interface HeldScreenFrame {
+    readonly cx: number;
+    readonly cy: number;
+    readonly hx: number;
+    readonly hy: number;
+    readonly s: number;
+    readonly settled: boolean;
+}
+/**
+ * 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).
+ */
+export interface HeldPoseSource {
+    frame(entity: Entity): HeldScreenFrame | undefined;
+    part?(entity: Entity, x: number, y: number): string | null;
+}
+/** The stack's slot for the pose source — a mutable box, so the renderer can arrive after install (as `framePick`). */
+export interface HeldPoseSlot {
+    current: HeldPoseSource | null;
+}
+/** The hand's numbers (desk.js `HOLD` and its wheel handler): the zoom's floor (put down below it) and ceiling, the wheel's rate, the mute, the press slop. */
+export declare const HOLD_INPUT: {
+    readonly zoomMin: 0.72;
+    readonly zoomMax: 3;
+    readonly wheelRate: 0.0105;
+    readonly muteMs: 400;
+    readonly muteMoreMs: 250;
+    readonly slopPx: 3;
+};
+/** The held object, or undefined. */
+export declare function heldEntity(world: World): Entity | undefined;
+export declare function createHeldInput(world: World, opts: {
+    readonly pose: HeldPoseSlot;
+}): System;

package/dist/types/packages/core/src/systems/insert-ghost.d.ts

@@ -12,6 +12,8 @@
  *    out-of-ECS hand-off (`drainCreatedSelections`); they are drained on the
  *    commit tick and applied HERE one tick later, when the projection is
  *    alive — the select-on-grab the ghost held transfers to the real widget.
+ *    Not to a twin created INSIDE a container: it is no member of this frame
+ *    (`Selected ⇒ Active`, nested-canvas.ts), so the drop selects nothing.
  *
  *  - RETIRING (`GhostRetiring`, cancel / rejected drop): despawned when the
  *    fly-back `TransformTween` lands (camera-sim removes it on arrival).

package/dist/types/packages/core/src/systems/l0-input.d.ts

@@ -20,6 +20,20 @@
  * cannot take `edit().set`). Facts are always true: `surfaceHandled` events
  * still land, but carry the one-tick `HandledByWidget` tag L1/L2 read (the
  * pinned widget-event contract, design-002 §8).
+ *
+ * THE CUT (2026-09-26): a pointer's fold ENDS at its transition (down / up /
+ * cancel), so a tick that carries `WentDown`/`WentUp` carries the pointer AT
+ * the press or the release — picking hits what was pressed, recognizers judge
+ * the release where it happened. The first event past a closed fold ends the
+ * tick's drain: it and everything behind it (every pointer, every key — the
+ * processed events stay a PREFIX of arrival order) are the next tick's facts.
+ * Before the cut, a click whose release coalesced with a far move into one
+ * frame published `WentUp` at the MOVE's point: the tap failed its slop, the
+ * drag measured its dead zone to a point reached after the release and went
+ * Active on the clicked object — which then followed the cursor (a ghost
+ * drag; found under CDP input in apps/desk, reachable by a quick tap and
+ * flick). Between transitions moves and wheel deltas still fold: every
+ * consumer reads the latest position or the tick's accumulated deltas.
  */
 import type { System, TickSystem, World } from "@vibecook/strata-ecs";
 import type { InputQueue } from "../input/queue";

package/dist/types/packages/core/src/systems/l1-pick.d.ts

@@ -42,17 +42,69 @@
  * pickTopAt, so pick can never diverge from paint), then the CanvasSurface
  * entity as the guaranteed fallback (design-001 §4). Relations are written
  * change-only (design-002 §4 hygiene). Wires/ports are M8 — skipped.
+ *
+ * `pickAt` is the exact pick OUT of the tick (petition I27 — the desk's
+ * `handle.pick`, a host's right-click): the `TouchesExact` body above run on
+ * the world as the last tick left it, read-only — one body, so a host's pick
+ * and a press can never disagree.
  */
 import type { Entity, System, TickSystem, World } from "@vibecook/strata-ecs";
 import { SpatialIndex } from "../../../kernel/src/index";
 import { type WirePickSource } from "../ops/point-pick";
+/**
+ * The FRAME pick source (design-014, B3b): the ground's answer to "what is
+ * under this world point on card `e`" — `content`, `frame` (the chrome band
+ * outside the content rect), `outside`, or a PART the registered card program
+ * names (`close`, `lock` …) — or `undefined`: the source has NO GEOMETRY for the card
+ * (the ground's pipelines are still compiling, the card has not been drawn yet, or
+ * creation failed), and the box tier's answer stands. `undefined` is not `outside`: a
+ * card the ground cannot see is still a card (B9 review blocker 1 — a source that
+ * answered `outside` there made every card unclickable until the first build, and for
+ * good when `Ground.create` rejected). `pad()` is how far the chrome reaches past the
+ * content rect, world units: the spatial index holds content rects, so
+ * `picking` widens its search by it and asks the source about candidates the
+ * boxes missed. Set on the interaction stack by the ground layer at mount;
+ * `null` = every hit is the box's (the stratified profile).
+ */
+export interface FramePickSource {
+    pad(): number;
+    hit(e: Entity, wx: number, wy: number): string | undefined;
+    /**
+     * The source's geometry is MOVING under a still pointer (a reveal growing a control, a lift): `picking` runs
+     * every frame this answers true, so the part under a motionless pointer is the part that is there now. Absent
+     * = never; the pointer and the spatial index are then the only wakes (B9 review).
+     */
+    live?(): boolean;
+    /**
+     * The widgets the source draws LIFTED this frame — above the frame's own order and away from their facts (design-015 §6's
+     * print in a hand, flicked or gliding; D3t-a): the spatial index still holds their fact rects, so the frame tier asks
+     * these FIRST, wherever they are drawn, and the topmost that answers is the hit — a press catches a gliding print where
+     * it is, and its old rect no longer does (its geometry says `outside` there). Absent = none.
+     */
+    lifted?(): Iterable<Entity>;
+}
+/** The stack's slot for the frame pick source — a mutable box, so the ground can arrive after install. */
+export interface FramePickSlot {
+    current: FramePickSource | null;
+}
+/** What a press at a point would touch (`TouchesExact`): the entity, and the PART under it (`""` the thing itself — design-014). */
+export interface PointPick {
+    readonly entity: Entity;
+    readonly part: string;
+}
 export interface PickingSystems {
     spatialSync: TickSystem;
     picking: System;
     /** The shared spatial index — snap/drop/marquee consume the SAME instance. */
     index: SpatialIndex<Entity>;
+    /**
+     * The exact pick OUT of the tick (petition I27): what a press at a SCREEN point (CSS px of the view) would touch now — the
+     * `TouchesExact` body `picking` runs, on the world as the last tick left it and the camera as it stands; `undefined` over the bare
+     * canvas, and everywhere while the pegboard drawer is out (the desk inert, design-017 §4). Read-only: no relation, no tag, no stamp.
+     */
+    pickAt(sx: number, sy: number): PointPick | undefined;
     /** Nav-op seam (design-004 §7): forget every last-known AABB so the next
      *  spatialSync pass repopulates the cleared index from the new Active set. */
     clearCaches(): void;
 }
-export declare function createPickingSystems(world: World, index?: SpatialIndex<Entity>, wires?: WirePickSource): PickingSystems;
+export declare function createPickingSystems(world: World, index?: SpatialIndex<Entity>, wires?: WirePickSource, frames?: FramePickSlot): PickingSystems;

package/dist/types/packages/core/src/systems/l2-arbitrate.d.ts

@@ -10,12 +10,26 @@
  * one ClaimedBy write per pointer per pass (`setRelation` is silent last-wins —
  * a mis-ordered arbitration would otherwise be undetectable).
  *
+ * ONE PASS PER TICK (2026-09-26): a strata system body runs once per matching
+ * CHUNK, and the recognizer kinds live in different archetypes — so while
+ * arbitration was a chunk system, the tie rule compared claimants only within
+ * one batch. The first batch's claimant won and failed the rest; a later batch,
+ * reading `ClaimedBy` before the flush, claimed as well and failed back (a
+ * pointer could end claimed by a Failed recognizer, both claimants dead). It is
+ * a tick system now: it collects EVERY claimant of the tick, then decides once
+ * per pointer. A claimant that lost this tick's tie fails even from a terminal
+ * phase — a Tap's `Recognized` — so a pointer gets one outcome, never a drag
+ * AND the tap it beat (as when the drag claims first: tap-then-drag fails the
+ * pending tap).
+ *
  * `dragRoute` — the ONE pan/marquee/move decision, latched at Drag activation
- * via route tags; the route never changes mid-gesture (design-003 §4.4).
+ * via route tags; the route never changes mid-gesture (design-003 §4.4). A
+ * canvas drag reads the pointer's latched shift to choose between the tool's
+ * `canvasDrag` and `canvasDragShift` (design-015 §9, D2a-core).
  */
-import type { System } from "@vibecook/strata-ecs";
-export declare function createArbitrationSystems(): {
-    arbitration: System;
+import type { System, TickSystem, World } from "@vibecook/strata-ecs";
+export declare function createArbitrationSystems(world?: World): {
+    arbitration: TickSystem;
     dragRoute: System;
 };
 /** Wheel recognizers never claim; exported so tests can assert the invariant set. */

package/dist/types/packages/core/src/systems/l2-recognize.d.ts

@@ -3,7 +3,9 @@
  *
  * `ctl:spawn`  — cancelSweep (consumes the one-tick CancelRequest) →
  *                recognizerSpawn (tool profiles; pinch on 2nd touch suspends
- *                singles; wheel recognizers are `Simultaneous`) →
+ *                singles; wheel recognizers are `Simultaneous`; a primary
+ *                press only — a secondary one is a point, a middle one its
+ *                pan's drag: petition I28, press-button.ts) →
  *                recognizerIntegrity (requiredWatches counts, capture death,
  *                suspension lift). Newborns are identity-only until the
  *                ctl:spawn flush, so integrity naturally skips them until the

package/dist/types/packages/core/src/systems/l3-behave.d.ts

@@ -20,7 +20,10 @@
  */
 import type { System, World } from "@vibecook/strata-ecs";
 import type { CommitSink } from "../engine/commit-sink";
-export declare function createSelectMoveBehaviors(world: World, sink: CommitSink): {
+import type { NavGeometrySlot } from "../nav/nav-geometry";
+export declare function createSelectMoveBehaviors(world: World, sink: CommitSink, opts?: {
+    readonly navGeometry?: NavGeometrySlot;
+}): {
     selectBehavior: System;
     moveBehavior: System;
 };

package/dist/types/packages/core/src/systems/l3-claim.d.ts

@@ -22,6 +22,13 @@
  * Same-widget double-grab guard: a widget already in another recognizer's
  * `Drags` set is skipped (first gesture owns it) — two `ctx.addComponent(Grab)`
  * for one widget in one frame would hit strata's flush-time duplicate policy.
+ *
+ * The tape (design-015 §5.1, D2a-core): a `Locked` widget gets no rider from
+ * either claim — never moved, never resized by a gesture — and nothing else
+ * changes: select-on-grab still selects it, the pointer is still claimed, and
+ * the untaped members of the same selection move without it. A claim whose set
+ * is all tape moves nothing and commits nothing (the release paths commit only
+ * what carries a `Grab`).
  */
 import type { System, World } from "@vibecook/strata-ecs";
 export declare function createClaimSystems(world: World): {

package/dist/types/packages/core/src/systems/l3-connect.d.ts

@@ -54,4 +54,4 @@ export interface ConnectSystems {
  *   one-frame `Targets` staleness on snapping — the router's pattern).
  * @param _wires reserved (the wire narrow-phase source; connect reads `Targets`).
  */
-export declare function createConnectSystems(_world: World, sink: CommitSink, _index: SpatialIndex<Entity>, _wires: WirePickSource): ConnectSystems;
+export declare function createConnectSystems(world: World, sink: CommitSink, _index: SpatialIndex<Entity>, _wires: WirePickSource): ConnectSystems;

package/dist/types/packages/core/src/systems/l3-drop.d.ts

@@ -17,7 +17,36 @@
  * relation version, and any churn wakes every row-filtered observer world-wide
  * (design-002 §4). Both clear when no container is under the bounds; the move
  * behavior clears them on every terminal path.
+ *
+ * THIRD SIGNAL (2026-09-06, design-013 §5 rev 6 / GLOW.md §3): `DragBounds` on
+ * the recognizer — the same post-move union this system computes for its
+ * spatial query, published instead of discarded. The overlap glow is cast light
+ * from the lifted set's own SDF, so the compose reflector needs its rect; there
+ * is no second computation and no new walk. Change-only over all four fields,
+ * for the same reason the other two are: a value write stamps, and a still
+ * frame must cost nothing.
  */
 import type { Entity, System, World } from "@vibecook/strata-ecs";
 import type { SpatialIndex } from "../../../kernel/src/index";
-export declare function createDropSystem(world: World, index: SpatialIndex<Entity>): System;
+import type { CanvasRect } from "../canvas/frame-view";
+import { type NavGeometrySlot } from "../nav/nav-geometry";
+import type { PortalAffine } from "../../../kernel/src/index";
+/** Is every one of these a GPU OBJECT (an `object` kind binding, design-015 §5.2)? The desk's drop rules apply to an all-object set. */
+export declare function objectsOnly(world: World, entities: readonly Entity[]): boolean;
+/**
+ * A container's FACE and its inside's embedding for a drop (design-015 §9): the renderer's word
+ * through the nav geometry seam under the current camera (the face as drawn), else core's static
+ * portal rect and default framing. `undefined` = the container has no face (no area).
+ */
+export declare function dropFaceOf(world: World, container: Entity, slot: NavGeometrySlot | undefined): {
+    readonly face: CanvasRect;
+    readonly affine: PortalAffine;
+} | undefined;
+/** Is the world point inside the rect (edges included)? */
+export declare const insideRect: (r: CanvasRect, x: number, y: number) => boolean;
+export interface DropPlacementPolicy {
+    canIngress(widgetTypeId: string, targetContainer: Entity): boolean;
+    /** K9: may an object of this type be made in this frame at all — the root's CanvasType placement (inside a container, `canIngress`). */
+    canPlace?(widgetTypeId: string, targetFrame: Entity): boolean;
+}
+export declare function createDropSystem(world: World, index: SpatialIndex<Entity>, placement?: DropPlacementPolicy, navGeometry?: NavGeometrySlot): System;

package/dist/types/packages/core/src/systems/l3-marquee.d.ts

@@ -13,7 +13,8 @@
  * global tag version, design-003 §5.7). Selection commits ONCE at terminal
  * (`JustEnded`): replace with the hits, or union when the watched pointer holds
  * shift; `SelectionVersion` bumps once (the v1 marquee lesson). No `access.write`
- * — reads + the buffer + ctx selection tags only.
+ * — reads + the buffer + ctx selection tags only. A `Locked` widget is never a
+ * hit (design-015 §5.1, Q-g: the tape keeps it out of the vellum).
  *
  * Camera staleness: both corners convert with the CURRENT camera, so a mid-
  * marquee camera move re-projects the rect (accepted — design-002 §2).

package/dist/types/packages/core/src/systems/l3-ports.d.ts

@@ -7,7 +7,7 @@
  * Three triggers materialize a widget's declared ports (registry decl → kernel
  * `portAnchor`; a port carries Port + PortAnchor + PortOf → widget, and NO
  * Position/Size — `spatialSync` must never see it; design-004 §6, the
- * SelectionBox precedent). Because ports carry no Position/Size, this system
+ * precedent of the retired selection box). Because ports carry no Position/Size, this system
  * gives them their OWN tiny world AABB in the shared spatial index so they are
  * pickable (design-003 §3 port tier):
  *   (a) connect tool → widgets in viewport+overscan (`200/zoom`); materialize at

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

@@ -8,6 +8,11 @@
  * (2) `ActiveTool` override — pan tool → "grab"; (3) else the mouse pointer's
  * `Targets` kind — a `HandleSpec` → directional resize, an entity with
  * `Position` (widget) → "default", `CanvasSurface`/none → "default".
+ * The pegboard tray (design-017 §4, K3): a specimen on its board a thing to take, "grab", its copy lifted "grabbing" (K9), over
+ * 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.
  *
  * Scheduled on the `CanvasSurface` anchor query (exactly one such entity,
  * guaranteed by install — the same idiom `pointerIngest` uses in l0-input.ts)