@vibecook/ice 0.1.0

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

@@ -0,0 +1,48 @@
+/**
+ * Chrome derive systems (design-004 §5 chrome plane, §8 LOD; `derive` phase).
+ *
+ * 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`.
+ *
+ *   HANDLE PICKING (the point of the design): handles carry a world AABB, so the
+ *   `react`-phase `spatialSync` indexes them automatically and `picking` resolves
+ *   a corner grab to the handle (HandleSpec has pick priority) → `dragRoute`
+ *   routes `RoutedResize` → `resizeBehavior` runs. Nothing here touches the index.
+ *
+ *   HANDLES ARE SCREEN-CONSTANT: a handle's world size is `HANDLE_PICK_PX / zoom`
+ *   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").
+ *
+ *   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.)
+ *
+ *   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
+ *   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
+ *   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→
+ *   measure loop converges (§2). The stored w,h are the effective size at the
+ *   tier transition (what the tier "was computed from").
+ */
+import type { System, TickSystem, World } from "@vibecook/strata-ecs";
+export declare function createSelectionChromeSystem(world: World): TickSystem;
+export declare function createBreakpointSystem(_world: World): System;

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

@@ -0,0 +1,19 @@
+/**
+ * cleanup phase — nothing transient crosses frames (design-002 §2; design-003
+ * §4.1 reap, §8 CancelRequest one-tick rule).
+ *
+ * `recognizerReap` destroys terminal recognizers at terminal +1 frame: a Just*
+ * marker means the transition happened THIS tick (markers clear later this
+ * phase, but ctx reads are pre-flush) — no marker means the tag has lingered a
+ * full frame and every edge-triggered consumer has run. `ClaimedBy`/`Watches`/
+ * `Captures`/`Drags` edges auto-clear with the despawn.
+ *
+ * `oneTickClear` then clears pointer transition tags, zeroes wheel deltas,
+ * clears all Just* markers, and consumes CancelRequest (a latched cancel would
+ * kill every future gesture forever).
+ */
+import { type System, type World } from "@vibecook/strata-ecs";
+export declare function createCleanupSystems(world: World): {
+    recognizerReap: System;
+    oneTickClear: System;
+};

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

@@ -0,0 +1,31 @@
+/**
+ * L0 — pointers & ingest (design-003 §2; `input` phase).
+ *
+ * Order inside the phase is load-bearing:
+ *
+ * `pointerLifecycle` runs BEFORE `pointerIngest` and reads only immediate
+ * values: a touch pointer whose buttons are still 0 at the top of a frame has
+ * been idle-up for a full frame (ingest zeroed buttons on the up frame), so its
+ * `ctx.destroy` lands at the input flush of frame up+1 — recognizers saw the up
+ * frame's `WentUp` in full. Tag-based detection cannot work in-phase (ingest's
+ * one-tick tags are deferred to the flush), hence values.
+ *
+ * `pointerIngest` is scheduled on the CANVAS-SURFACE anchor query (exactly one
+ * such entity, guaranteed by install) because a system body only runs when its
+ * query matches — and ingest must run on frames where no pointer entity exists
+ * yet (the first down CREATES the pointer). It drains the queue once per tick
+ * in two passes: fold events into per-pointer samples, then apply — existing
+ * pointers get immediate value writes + deferred one-tick tags; NEW pointers
+ * spawn once with their folded final state (an identity-only `ctx.spawn` handle
+ * 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).
+ */
+import type { System, TickSystem, World } from "@vibecook/strata-ecs";
+import type { InputQueue } from "../input/queue";
+export interface L0Systems {
+    pointerLifecycle: System;
+    pointerIngest: TickSystem;
+    pointerWorldSync: System;
+}
+export declare function createL0Systems(world: World, queue: InputQueue): L0Systems;

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

@@ -0,0 +1,44 @@
+/**
+ * L1 — spatial sync + targeting (design-003 §3; `react` phase).
+ *
+ * Two systems, run in this order:
+ *
+ * `spatialSync` maintains the kernel `SpatialIndex` over every Position+Size
+ * entity (widgets AND HandleSpec chrome — both carry a world AABB). It is a
+ * TICK system (strata 0.5.0) so the body runs EVERY frame — it is the writer
+ * that bumps
+ * `SpatialVersion`, and its own writes have no version stamp to gate on
+ * (design-002 §4), so it must run eagerly and stays cheap via a private
+ * last-known cache: an entity is re-`upsert`ed only when its AABB actually
+ * changed, and a cache-sweep removes entries no longer matched (despawns, or a
+ * lost Position/Size). Materialized ports are M8 — skipped.
+ *
+ * `picking` runs the dual pick (design-003 §3), gated by a version guard over
+ * `PointerVersion ∨ SpatialVersion`. `CameraVersion` does not exist — camera
+ * motion alone does not re-pick, an accepted staleness (design-002 §2). Pointer
+ * world position is derived from PointerScreen × Camera rather than the
+ * PointerWorld cell: PointerWorld lags a frame on the pointer's spawn (the
+ * pointerWorldSync writer cannot see a pointer spawned in the same input phase),
+ * which would mis-capture on the down frame — screen×camera is exact here.
+ *   - `Targets`      = radiused disc-vs-box pick with a screen-px release
+ *                      dead-band (hover is forgiving; hold the current target
+ *                      while the pointer stays within its expanded bounds).
+ *   - `TouchesExact` = r=0 point pick (grab is precise; no dead-band).
+ * Pick priority is plane priority: HandleSpec chrome first, then widgets by
+ * StackZ descending, 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.
+ */
+import type { Entity, System, TickSystem, World } from "@vibecook/strata-ecs";
+import { SpatialIndex } from "@ice/kernel";
+import { type WirePickSource } from "../ops/point-pick";
+export interface PickingSystems {
+    spatialSync: TickSystem;
+    picking: System;
+    /** The shared spatial index — snap/drop/marquee consume the SAME instance. */
+    index: SpatialIndex<Entity>;
+    /** 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;

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

@@ -0,0 +1,30 @@
+/**
+ * L1 — wire geometry sync (design-004 §6 ports & wires runtime; `react` phase,
+ * AFTER `spatialSync`).
+ *
+ * A wire is a durable reified edge (Wire tag + WireFrom/WireTo → widgets +
+ * WirePorts ids). Its RENDER + PICK geometry is a pure function of the two
+ * endpoint widget rects and their port declarations (design-001 §5.3: geometry
+ * never reads a port entity — culled endpoints resolve by construction). This
+ * TICK system (strata 0.5.0) recomputes each wire's cubic once per frame and
+ * keeps a private cache so the shared spatial index only churns on real
+ * movement — exactly the `spatialSync` idiom, and the reason it must run every
+ * frame: it is a `SpatialVersion` writer and cannot gate on the version it bumps.
+ *
+ * Per wire: resolve WireFrom/WireTo → endpoint Position+Size + the port slot
+ * (PrefabId → widget registry → decl → kernel `portAnchor`) → `wireCubic` →
+ * `cubicAABB`. Endpoint or declaration unresolvable (mid-projection, a despawned
+ * widget, a removed port id) ⇒ the wire leaves the index (invisible to picking;
+ * the renderer draws nothing for it). The cache also feeds the `WirePickSource`
+ * the point-pick narrow-phases against (`ops/point-pick`), and exposes the
+ * screen-constant pick slop as `slopWorld = wirePickSlopPx / zoom`.
+ */
+import type { Entity, TickSystem, World } from "@vibecook/strata-ecs";
+import { type SpatialIndex } from "@ice/kernel";
+import type { WirePickSource } from "../ops/point-pick";
+export interface WireSyncSystem {
+    wireSync: TickSystem;
+    /** The narrow-phase source `pickTopAt` consults for wire entries. */
+    wires: WirePickSource;
+}
+export declare function createWireSync(world: World, index: SpatialIndex<Entity>): WireSyncSystem;

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

@@ -0,0 +1,40 @@
+/**
+ * L2 — arbitration + routing (design-003 §4.3–§4.4; `ctl:arbitrate`).
+ *
+ * Arbitration rule (v2-proven, generalized): the first recognizer to enter a
+ * claiming phase (`Active` for continuous, `Recognized` for discrete) claims
+ * every pointer it watches; same-frame ties resolve by priority
+ * Pinch > Drag > LongPress > Tap; every other non-terminal, non-`Simultaneous`,
+ * non-suspended recognizer watching a claimed pointer → `Failed`. The claim is
+ * world state: `ClaimedBy(pointer → recognizer)` (Law 4). DEV asserts at most
+ * one ClaimedBy write per pointer per pass (`setRelation` is silent last-wins —
+ * a mis-ordered arbitration would otherwise be undetectable).
+ *
+ * `dragRoute` — the ONE pan/marquee/move decision, latched at Drag activation
+ * via route tags; the route never changes mid-gesture (design-003 §4.4).
+ */
+import type { System } from "@vibecook/strata-ecs";
+export declare function createArbitrationSystems(): {
+    arbitration: System;
+    dragRoute: System;
+};
+/** Wheel recognizers never claim; exported so tests can assert the invariant set. */
+export declare const NEVER_CLAIMS: readonly [import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly dx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorX: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorY: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>, {
+    readonly dx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorX: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorY: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>, import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly pinch: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorX: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorY: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>, {
+    readonly pinch: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorX: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly anchorY: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>];

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

@@ -0,0 +1,45 @@
+/**
+ * L2 — recognizer lifecycle + per-kind FSMs (design-003 §4.1–§4.2).
+ *
+ * `ctl:spawn`  — cancelSweep (consumes the one-tick CancelRequest) →
+ *                recognizerSpawn (tool profiles; pinch on 2nd touch suspends
+ *                singles; wheel recognizers are `Simultaneous`) →
+ *                recognizerIntegrity (requiredWatches counts, capture death,
+ *                suspension lift). Newborns are identity-only until the
+ *                ctl:spawn flush, so integrity naturally skips them until the
+ *                next frame — by which time their edges are placed.
+ * `ctl:recognize` — per-kind systems. Transitions go through the PhaseSet via
+ *                `ctx` (visible at this phase's flush — arbitration reads them
+ *                the same frame); field updates are immediate `edit().set`
+ *                under declared `access.write`.
+ *
+ * All timing reads FrameInfo.now (the engine clock); all thresholds read
+ * the GestureSettings RESOURCE (live-tunable, design-005 §4) with the
+ * GESTURE_DEFAULTS constants as the unset fallback. Gesture math is screen-space totals + zoom-at-claim — never
+ * live PointerWorld (design-002 §2 staleness rule).
+ */
+import type { World } from "@vibecook/strata-ecs";
+import { type System } from "@vibecook/strata-ecs";
+export type SingleKindName = "tap" | "longPress" | "drag";
+/** Tool id → single-pointer recognizer set spawned per down (design-003 §4.1). */
+export type SpawnProfiles = Readonly<Record<string, readonly SingleKindName[]>>;
+export declare const DEFAULT_SPAWN_PROFILES: SpawnProfiles;
+export interface L2Deps {
+    readonly world: World;
+    readonly profiles?: SpawnProfiles;
+}
+export interface L2Systems {
+    cancelSweep: System;
+    recognizerSpawn: System;
+    /** Same design slot as recognizerSpawn (design-002 §2) over the wheel-source query. */
+    wheelSpawn: System;
+    recognizerIntegrity: System;
+    tapSystem: System;
+    longPressSystem: System;
+    dragSystem: System;
+    pinchSystem: System;
+    wheelSystem: System;
+    /** Resolves Pending `Sequence`/`RequiresFail` edges; last in `ctl:recognize`. */
+    dependencySystem: System;
+}
+export declare function createL2Systems({ world, profiles }: L2Deps): L2Systems;

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

@@ -0,0 +1,24 @@
+/**
+ * L3 — select + move behaviors (design-003 §5 items 1, 3, 5; `ctl:behave`).
+ *
+ * The behavior contract (design-003 §5): read riders/edges attached at
+ * ctl:claim; per frame (persistent `Active`) apply ABSOLUTE live writes from
+ * rider origins + gesture totals; on `JustEnded` emit ONE commit (through the
+ * CommitSink seam — M5 swaps in the doc transaction); on `JustCancelled`
+ * restore from riders — Position AND StackZ (a forgotten StackZ restore leaves
+ * the cell diverged forever); remove riders and gesture-scoped edges on every
+ * terminal path. Discrete actions edge-trigger on `Just*` markers only.
+ *
+ * Move outcome tree (design-003 §5.5, three-way via dropSystem's signals):
+ *   DropTarget + OverlapCandidate on the container → CONSUME (reparent intent);
+ *   DropTarget without OverlapCandidate → FLY-BACK (no commit; TransformTween
+ *     rider per widget — the tween HOLDS the claim, design-001 §3 amended);
+ *   no DropTarget → COMMIT (final Position + StackZ per live Drags edge).
+ * Without dropSystem installed no DropTarget ever exists ⇒ plain commits.
+ */
+import type { System, World } from "@vibecook/strata-ecs";
+import type { CommitSink } from "../engine/commit-sink";
+export declare function createSelectMoveBehaviors(world: World, sink: CommitSink): {
+    selectBehavior: System;
+    moveBehavior: System;
+};

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

@@ -0,0 +1,26 @@
+/**
+ * ctl:claim — the rider settle point (design-003 §4.5).
+ *
+ * This sub-phase exists for exactly one reason: riders (`Grab`) and edges
+ * (`Drags`) attached via `ctx` must be readable by the behaviors that consume
+ * them ON THE CLAIM FRAME — without it, the first mutation lags a frame and a
+ * claim-frame `read(w, Grab)` throws (design-003 review C1).
+ *
+ * `moveClaim` (JustActive × RoutedMove): select-on-grab, `Drags` edges over the
+ * dragged set, `Grab` per widget with the CURRENT Position/Size/StackZ embedded
+ * in the command payload, and the StackZ elevate (an immediate value write —
+ * part of the gesture divergence, restored from `Grab.z` on cancel).
+ *
+ * `resizeClaim` (JustActive × RoutedResize): `Drags` + `Grab` over the Selected
+ * ∧ Resizable set; the anchor lives on the captured handle's `HandleSpec` — no
+ * extra state.
+ *
+ * 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.
+ */
+import type { System, World } from "@vibecook/strata-ecs";
+export declare function createClaimSystems(world: World): {
+    moveClaim: System;
+    resizeClaim: System;
+};

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

@@ -0,0 +1,57 @@
+/**
+ * L3 — connect behavior (design-003 §5 item 8, §4.5 connectClaim; design-004 §6;
+ * `ctl:claim` + `ctl:behave`). The node-editor core gesture: drag from a source
+ * port to a compatible target port, commit ONE wire.
+ *
+ * `connectClaim` (JustActive × RoutedConnect): latch the source port — the
+ * recognizer's `Captures` target must be a Port entity (dragRoute guarantees it,
+ * or the connect tool started the drag). Recognizer field-sets are per-kind
+ * (Drag), so per-gesture claim state lives in a closure Map keyed by recognizer
+ * (the `tweenStart`/camera-sim precedent), holding the source WIDGET + port id +
+ * world anchor + accepts-keys. The preview buffer arms here.
+ *
+ * `connectBehavior` (a TICK system, like marquee, so it can CLEAR the preview the
+ * frame after the gesture ends): per Active frame it writes the out-of-ECS
+ * `WirePreviewBuffer` (source anchor → pointer world, snapped to a COMPATIBLE
+ * port anchor when the watched pointer `Targets` one; type check via the widgets'
+ * port decls; self-wire never compatible). On `JustEnded` over a compatible port
+ * it commits `{kind:"connect", wires:[{from,to,fromPort,toPort}]}` (the doc sink
+ * spawns the wire); elsewhere it commits nothing.
+ *
+ * PREVIEW CONTINUITY — SIMPLIFICATION ACCEPTED (design-003 §5.8 / design-002 §8):
+ * the preview clears on JustEnded+1 (one linger frame) rather than persisting
+ * until the projected wire entity places (the promote-sweep analog). Full
+ * continuity — hand the preview off to the freshly-synced wire with no blink —
+ * is polish deferred; the one-frame gap is invisible in practice.
+ */
+import type { Entity, System, TickSystem, World } from "@vibecook/strata-ecs";
+import { type SpatialIndex } from "@ice/kernel";
+import type { CommitSink } from "../engine/commit-sink";
+import type { WirePickSource } from "../ops/point-pick";
+/**
+ * The out-of-ECS connect preview (design-004 §6; the marquee-buffer precedent).
+ * `sx,sy` = source port world anchor; `tx,ty` = the projected endpoint (pointer
+ * world, or a snapped compatible-port anchor); `compatible` gates the landing.
+ */
+export interface WirePreviewBuffer {
+    active: boolean;
+    compatible: boolean;
+    sx: number;
+    sy: number;
+    tx: number;
+    ty: number;
+}
+export interface ConnectSystems {
+    connectClaim: System;
+    connectBehavior: TickSystem;
+    previewBuffer: WirePreviewBuffer;
+}
+/**
+ * Signature carries the full graph-slice wiring (design brief) though connect
+ * reads only `Targets` today:
+ * @param _world reserved (systems reach world state via `ctx`).
+ * @param _index reserved (future: a fresh event-time port pick to drop the
+ *   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;

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

@@ -0,0 +1,21 @@
+/**
+ * L3 — draw behavior (design-005 §3 `draw(widgetType)` tool; `ctl:behave`,
+ * after connect, before camera — design-003 §5 order).
+ *
+ * A `RoutedDraw` drag creates ONE widget from the release rect: at
+ * `JustEnded`, screen start+total → world rect (Camera at release), floored
+ * at the widget's `minSize`; a sub-slop release (a click) places the
+ * widget's DEFAULT size centered on the point. Commit is one `create`
+ * intent through the sink — the doc sink spawns via the same override
+ * builder as `ops.spawnWidget`, so the two paths can never diverge.
+ * Cancel/fail commit nothing. The widget type comes from the ACTIVE tool's
+ * `draw` config (latched per drag at claim would be stricter; tools switch
+ * via `ops.setTool` which cancels active gestures first, so the active
+ * tool is stable for a live drag by construction).
+ *
+ * Mid-drag rect preview is recorded polish (design-001 §3's full
+ * draft→promote protocol is the vNext shape); v1 draws nothing until release.
+ */
+import type { System, World } from "@vibecook/strata-ecs";
+import type { CommitSink } from "../engine/commit-sink";
+export declare function createDrawBehavior(world: World, sink: CommitSink): System;

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

@@ -0,0 +1,21 @@
+/**
+ * L3 — drop candidate detection (design-003 §5 item 4; `ctl:behave`, ordered
+ * AFTER moveBehavior so it tests POST-move bounds).
+ *
+ * For Active `RoutedMove` drags: spatial-query the dragged union bounds for
+ * `Container` widgets (∉dragged), pick the topmost by StackZ, and publish two
+ * signals the move-outcome tree consumes (l3-behave §5.5):
+ *   - `DropTarget(recognizer → container)` — set for the container under the
+ *     bounds REGARDLESS of an accepts-match (so the outcome tree can distinguish
+ *     a rejected drop from a plain move).
+ *   - `OverlapCandidate` on the container — ONLY when the container's `Accepts`
+ *     intersects the dragged set's `Provides` (a widget with no `Provides` never
+ *     matches; RFC-004 contracts).
+ * BOTH are strictly change-only: `setRelation`/`addTag` bump the GLOBAL tag/
+ * 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.
+ */
+import type { Entity, System, World } from "@vibecook/strata-ecs";
+import type { SpatialIndex } from "@ice/kernel";
+export declare function createDropSystem(world: World, index: SpatialIndex<Entity>): System;

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

@@ -0,0 +1,35 @@
+/**
+ * L3 — marquee behavior (design-003 §5 item 7, §5.7; `ctl:behave`). Rider-free.
+ *
+ * Two entry paths, one system (anchored on the CanvasSurface entity so the body
+ * runs EVERY frame — the preview must clear the frame the gesture ends):
+ *   - desktop: an Active `RoutedMarquee` Drag — rect from `Drag.start + total`
+ *     (screen), both corners converted to world via the kernel seam.
+ *   - touch:   a Recognized `LongPress` capturing the canvas, riding its
+ *     continuous tail — rect from `start → cur` (§4.2, v2's proven path; no
+ *     `Sequence` machinery).
+ * Per frame the hit ENTITY SET goes into an out-of-ECS render buffer
+ * (`MarqueeBuffer`, recomputed each frame — preview-as-tags would churn the
+ * 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.
+ *
+ * Camera staleness: both corners convert with the CURRENT camera, so a mid-
+ * marquee camera move re-projects the rect (accepted — design-002 §2).
+ */
+import type { Entity, TickSystem, World } from "@vibecook/strata-ecs";
+import { type SpatialIndex } from "@ice/kernel";
+/** The out-of-ECS marquee preview (design-003 §5.7): rect + hit set, recomputed each frame. */
+export interface MarqueeBuffer {
+    rect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+    hits: Entity[];
+}
+export declare function createMarqueeBehavior(world: World, index: SpatialIndex<Entity>): TickSystem & {
+    buffer: MarqueeBuffer;
+};

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

@@ -0,0 +1,30 @@
+/**
+ * L3 — port materialization (design-004 §6 ports & wires runtime; `derive`
+ * phase, BEFORE `selectionChrome`). The LOCKED gating from design-004 §6 /
+ * design-001 §5.3: port ENTITIES are runtime and on-demand, so steady-state
+ * pan/zoom with the select tool spawns ZERO ports.
+ *
+ * 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
+ * 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
+ *       the overscan band, keep across a ×1.5 hysteresis band;
+ *   (b) any local pointer `Targets` a ported widget → that widget's ports;
+ *   (c) an Active `RoutedConnect` drag → COMPATIBLE ports (accepts-key
+ *       intersection with the source port; empty accepts = wildcard) light up
+ *       STAGED by distance-to-pointer, capped to the nearest 256 within the
+ *       `portLightUpRadiusPx` screen radius (rev 2: "all visible" at a 10k
+ *       zoomed-out view meant multi-second fills + sustained pick churn).
+ *
+ * Spawn budget ≤ `portSpawnPerFrame` (64) per frame — staging spreads a big
+ * light-up across frames. A widget's ports reap when every trigger lapsed for
+ * `portReapGraceMs`, or immediately if the widget died. Anchors recompute each
+ * frame and rewrite Port entities + index entries CHANGE-ONLY (a still widget
+ * churns nothing). `SpatialVersion` bumps only on a real index change.
+ */
+import type { Entity, TickSystem, World } from "@vibecook/strata-ecs";
+import { type SpatialIndex } from "@ice/kernel";
+export declare function createPortMaterialize(world: World, index: SpatialIndex<Entity>): TickSystem;

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

@@ -0,0 +1,17 @@
+/**
+ * L3 — resize behavior (design-003 §5 item 6; `ctl:behave`).
+ *
+ * A drag captured on a `HandleSpec` chrome entity (route `RoutedResize`, riders
+ * attached by `resizeClaim` §4.5). Per Active frame it writes ABSOLUTE Position+
+ * Size for every live `Drags` target from its `Grab` origin + `Drag.total /
+ * zoomAtClaim`, resized about the FIXED opposite edge/corner of the grabbed
+ * handle (`n`/`s` height-only, `e`/`w` width-only, corners both). Modifiers ride
+ * the watched pointer's `PointerMods`: `alt` = resize about center, `shift` =
+ * preserve aspect (corner handles). Min size clamps to 1×1. `JustEnded` emits ONE
+ * `resize` commit (Position+Size per live target); `JustCancelled`/`JustFailed`
+ * restore from `Grab`. Every terminal path removes `Grab` and the `Drags` edges
+ * (mirrors l3-behave's clearGestureState; resize has no DropTarget).
+ */
+import type { System, World } from "@vibecook/strata-ecs";
+import type { CommitSink } from "../engine/commit-sink";
+export declare function createResizeBehavior(world: World, sink: CommitSink): System;

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

@@ -0,0 +1,19 @@
+/**
+ * L3 — snap (design-003 §5 item 2, §6; `ctl:behave`, ordered BEFORE moveBehavior).
+ *
+ * For Active `RoutedMove` drags whose dragged set is a `SnapSource`: compute the
+ * intended PRE-SNAP rect as `Grab.origin + Drag.total / zoomAtClaim`, unioned
+ * over the dragged widgets — NEVER last-applied `Position` (one frame stale ⇒
+ * guide-chasing oscillation, design-003 §5.2 red-team; `Grab` is readable here
+ * thanks to the ctl:claim settle point, §4.5). Candidates come from the SHARED
+ * spatial index (rect query = intended bounds expanded by threshold, filtered to
+ * `SnapTarget ∧ ∉dragged`; Visible filtering waits for cull). Threshold is
+ * `thresholdPx / zoomAtClaim` (screen-constant). The kernel `computeSnapGuides`
+ * does the Figma math; we write `SnapState{dx,dy}` on the recognizer (moveBehavior
+ * adds it to the absolute write). Guide CHROME entities (`GuideLine`) are deferred
+ * to the chrome-reflector milestone — SnapState only here. SnapState clears to 0,0
+ * when snap is off / no source / no candidate.
+ */
+import type { Entity, System, World } from "@vibecook/strata-ecs";
+import { type SpatialIndex } from "@ice/kernel";
+export declare function createSnapSystem(world: World, index: SpatialIndex<Entity>): System;

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

@@ -0,0 +1,24 @@
+/**
+ * L4 — cursor projection (design-003 §7; `derive` phase).
+ *
+ * Memoryless: resolved fresh every run from live world state, priority order
+ * (1) any LOCAL pointer with a live `ClaimedBy` — Drag+RoutedMove or a
+ * LongPress in Recognized → "grabbing"; RoutedResize → directional resize by
+ * the captured handle's `HandleSpec.anchor`; RoutedPan → "grabbing";
+ * (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".
+ *
+ * Scheduled on the `CanvasSurface` anchor query (exactly one such entity,
+ * guaranteed by install — the same idiom `pointerIngest` uses in l0-input.ts)
+ * so the body runs every frame even on tool switches with no pointer motion;
+ * `world.query(...)` inside then does the actual local-pointer scan (mirrors
+ * `oneTickClear`'s marker sweep in cleanup.ts).
+ *
+ * The resolved string is closure state; `readCursor()` exposes it — the DOM
+ * 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 & {
+    readCursor(): string;
+};

package/dist/types/packages/core/src/systems/measure-ingest.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Measurement ingest (design-004 §2; `input` phase).
+ *
+ * Drains the {@link MeasureQueue} once per tick and folds each auto-sized
+ * widget's latest content-box measurement into the `MeasuredSize` session rider
+ * — the effective-size source cull/hit/breakpoint consume where a widget is
+ * auto-sized (`MeasuredSize` where present and >0, else `Size`). Auto-sized
+ * widgets never commit `Size`; the doc stores authorial intent only.
+ *
+ * Scheduled on the CANVAS-SURFACE anchor query (exactly one such entity,
+ * guaranteed by install) — like `pointerIngest` — because the body must run on
+ * frames where no measured widget exists yet, and a tag-only query matches every
+ * archetype-independent (a tick system, strata 0.5.0): the drain runs exactly
+ * once per frame BY CONSTRUCTION.
+ *
+ * Two guards keep a hidden widget's `display:none` collapse out of the rider
+ * (the §2 double wall): the adapter never enqueues a `0×0` sample, and ingest
+ * skips `w===0 && h===0` again here. Real changes clear a **±1 px dead-band**
+ * against the current rider so sub-pixel RO jitter never restamps (which would
+ * churn breakpoint/cull downstream). Within one drain, samples fold last-wins
+ * per entity so a same-tick pair never double-`addComponent`s (strata's
+ * flush-time duplicate policy).
+ */
+import type { TickSystem, World } from "@vibecook/strata-ecs";
+import type { MeasureQueue } from "../input/measure-queue";
+export declare function createMeasureIngest(world: World, queue: MeasureQueue): TickSystem;