@vibecook/ice 0.1.0 → 0.3.0

package/dist/types/packages/core/src/ops/point-pick.d.ts

@@ -6,11 +6,13 @@
  * the tick are verified-unrestricted). One implementation so the two can
  * never disagree on ordering.
  *
- * Priority: HandleSpec chrome first (nearest edge), then widgets by StackZ
- * descending. Deliberately NOT plane-stratified: cross-plane z is stratified
- * visually (P2 GL composites above P1 DOM), but pick order is StackZ across
- * all surfaces — design-004 §1 names the mixed-overlap consequence and
- * accepts it; do not "fix" it here.
+ * Priority: HandleSpec chrome first (nearest edge), then widgets topmost by
+ * SIBLING ORDER (petition 8: the frame parent's ChildOf sequence, legacy
+ * (StackZ, entity) fallback for edge-less entities — compareStackOrder is the
+ * ONE comparator paint and pick share). Deliberately NOT plane-stratified:
+ * cross-plane z is stratified visually (P2 GL composites above P1 DOM), but
+ * pick order is sibling order across all surfaces — design-004 §1 names the
+ * mixed-overlap consequence and accepts it; do not "fix" it here.
  */
 import type { Component, Entity } from "@vibecook/strata-ecs";
 import type { Cubic, SpatialIndex } from "@ice/kernel";
@@ -33,10 +35,12 @@ export declare function distPointToBox(px: number, py: number, minX: number, min
  * Top pick under a world point within `rWorld` (point-in-box when 0).
  * Tier order (design-003 §3, amended for M8): HandleSpec chrome → PORT
  * entities (interaction affordances sit atop their widget edge) → widgets by
- * StackZ → WIRES (render in P0 under content; pick below widgets, above
+ * sibling order (topmost = compareStackOrder max; `ordinals` is the caller's
+ * frame ordinal map — SiblingOrderIndex — so paint and pick share one order)
+ * → WIRES (render in P0 under content; pick below widgets, above
  * canvas — render order and pick order agree). The canvas fallback stays the
  * caller's. Wires narrow-phase against their cached cubic (`wires` source;
  * without one, wire entries are skipped — coarse AABB hits would make fat
  * bounding boxes steal canvas taps).
  */
-export declare function pickTopAt(reader: PickReader, index: SpatialIndex<Entity>, wx: number, wy: number, rWorld: number, wires?: WirePickSource): Entity | undefined;
+export declare function pickTopAt(reader: PickReader, index: SpatialIndex<Entity>, wx: number, wy: number, rWorld: number, wires?: WirePickSource, ordinals?: ReadonlyMap<Entity, number>): Entity | undefined;

package/dist/types/packages/core/src/ops/sibling-order.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Sibling order — THE per-frame stacking source (petition 8; design-004 §1
+ * amendment). Within a frame, paint/pick/drop order IS the frame parent's
+ * ordered `ChildOf` sibling sequence: index 0 paints first (bottom), the tail
+ * paints last (top). The frame parent is `currentNavFrame(world) ?? BoardRoot`
+ * — every renderer/pick consumer shares this module so the orders can never
+ * diverge (the point-pick lesson, extended to the comparator).
+ *
+ * LEGACY FALLBACK (must keep working): when the `BoardRoot` resource is absent
+ * (a pre-schema-2 doc opened read-only, or a doc-less runtime world) OR an
+ * entity carries no `ChildOf` edge (bare runtime spawns), stacking falls back
+ * to the legacy `(StackZ.z asc, entity asc)` comparator. This module is the
+ * ONLY sanctioned StackZ reader outside the schema migration.
+ *
+ * Mixed frames — some entities ordinal-mapped, some fallback — are nominally
+ * impossible (the 1→2 migration hangs an edge on every durable widget, and a
+ * pre-schema-2 read-only doc has no BoardRoot at all, so it is all-fallback).
+ * The comparator still totals them: ordinal-mapped entities sort BELOW the
+ * fallback set (ordinals first in paint order), each group internally ordered
+ * by its own rule — documented so a stray bare spawn lands somewhere stable
+ * rather than somewhere random.
+ *
+ * Invalidation is PULL-ONLY, the strata 0.8.0 contract: `world.orderStamp
+ * (parent, ChildOf)` is a monotonic per-parent version consumers poll after a
+ * reactive wake; the wake itself is an `observeQuery` whose grammar names the
+ * relation (`Related(ChildOf)` — pure reorders turn it over).
+ */
+import type { Component, Entity, World } from "@vibecook/strata-ecs";
+/** Structural read both `World` and `SystemCtx` provide — all the comparator needs. */
+export interface StackOrderReader {
+    get<S>(e: Entity, c: Component<S>): S | undefined;
+}
+/**
+ * The frame parent — the entity whose `ChildOf` sibling sequence is the
+ * current frame's stacking order: the nav frame when inside a container, else
+ * the document's board root. `undefined` = a legacy world (pre-schema-2
+ * read-only doc / doc-less runtime) — everything is fallback-ordered.
+ */
+export declare function frameParent(world: World): Entity | undefined;
+/** `parent`'s sibling sequence as entity → position (the renderers' sort key). */
+export declare function buildOrdinals(world: World, parent: Entity): Map<Entity, number>;
+/**
+ * THE stacking comparator (ascending = paint order; the pick tier takes the
+ * max). Ordinal-mapped entities order by sibling position; entities missing
+ * from the map use the legacy `(StackZ asc, entity asc)` fallback among
+ * themselves and sort ABOVE the ordinal-mapped set (see the header note on
+ * nominally-impossible mixed frames).
+ */
+export declare function compareStackOrder(reader: StackOrderReader, ordinals: ReadonlyMap<Entity, number>, a: Entity, b: Entity): number;
+export interface SiblingOrderIndex {
+    /** The frame parent backing the current ordinal map (undefined = legacy world). */
+    parent(): Entity | undefined;
+    /** The stamp-checked ordinal map — rebuilt only when the frame parent or its `orderStamp` moved. */
+    ordinals(): ReadonlyMap<Entity, number>;
+    /** True when the next `ordinals()` would rebuild (cheap pull; no rebuild). */
+    stale(): boolean;
+    /**
+     * Arm the reorder wake: an `observeQuery` naming `ChildOf` (`Related`
+     * grammar — pure reorders and edge turnover both fire it). Callers pair it
+     * with `stale()`/`ordinals()` so other-frame churn stays a no-op.
+     */
+    observe(cb: () => void): () => void;
+}
+/**
+ * A pull-based ordinal cache over the CURRENT frame parent's sibling sequence.
+ * Consumers each hold their own instance (the cache is a cheap `getReverse`
+ * walk); correctness is shared through {@link compareStackOrder} and the
+ * stamp, never through instance identity.
+ */
+export declare function createSiblingOrderIndex(world: World): SiblingOrderIndex;

package/dist/types/packages/core/src/schema/meta.d.ts

@@ -31,6 +31,7 @@ export declare function defineComponent<const Sch extends RawSchema>(name: strin
 export declare function defineTag(name: string): Tag;
 export declare function defineRelation(name: string, opts?: {
     arity?: "one" | "many";
+    ordered?: boolean;
 }): Relation;
 export declare function defineResource<const Sch extends RawSchema>(name: string, schema: Sch, opts?: {
     durable?: boolean;

package/dist/types/packages/core/src/settings/defaults.d.ts

@@ -15,6 +15,8 @@ export declare const GESTURE_DEFAULTS: {
     readonly inertiaDecayMs: 325;
     readonly multiTapWindowMs: 280;
     readonly multiTapSlopPx: 20;
+    readonly wheelZoomSensitivity: 0.01;
+    readonly wheelZoomMaxStep: 10;
 };
 /** Pick radii + retarget dead-band (design-003 §3 L1 targeting). */
 export declare const POINTER_DEFAULTS: {
@@ -39,12 +41,55 @@ export declare const SNAP_DEFAULTS: {
     readonly enabled: true;
     readonly thresholdPx: 5;
 };
+/**
+ * Selection-chrome knobs (2026-07-17). `liftScale` mirrors the app's visual
+ * drag-lift scale (widgetlab CardShell: 1.05) so the union box can inflate a
+ * grabbed member's rect and keep WRAPPING the card it sees; 1 = no lift
+ * visual, no inflation.
+ */
+export declare const CHROME_DEFAULTS: {
+    readonly liftScale: 1;
+};
 /** Zoom clamp (design-003 §5 item 9 cameraControl) and frame dt clamp (design-002 §1). */
 export declare const CAMERA_DEFAULTS: {
     readonly minZoom: 0.1;
     readonly maxZoom: 5;
     readonly dtClampMs: 64;
 };
+/**
+ * The natural auto-framing band (2026-07-18, James: "not super zoomed in
+ * nor super zoomed out, should feel natural"): every DEFAULT framing —
+ * `ops.frameContent` at boot, the folder arrival camera, and the folder
+ * minis' portal affine (widgetlab keeps its preview in lockstep) — fits
+ * content via kernel `fitCamera` but never lands outside
+ * [fitMinZoom, fitMaxZoom], intersected with the session's hard
+ * CameraLimits. `ops.zoomToFit` stays UNCAPPED: an explicit "show me
+ * everything" beats natural.
+ */
+export declare const FIT_DEFAULTS: {
+    readonly pad: 80;
+    readonly minZoom: 0.5;
+    readonly maxZoom: 1;
+};
+/**
+ * Nav-transition motion constants (design-006 §4/§5, tuned in the approved
+ * 2026-07-15 mock). `responseMs` is the critically-damped spring response for
+ * ENTER; exit runs at `exitResponseFactor ×` (returning is lighter). Response
+ * scales `durationPerOctave` per zoom-octave beyond `baseOctaves` (Apple's
+ * duration-with-distance). Beyond `freezeOctaves` a flight cannot be presented
+ * geometrically (Chromium raster-scale swing — design-006 §5): the start depth
+ * caps at `capFactor ×` arrival and the transition presents as a crossfade.
+ */
+export declare const NAV_TRANSITION_DEFAULTS: {
+    readonly responseMs: 420;
+    readonly exitResponseFactor: 0.8;
+    readonly durationPerOctave: 0.12;
+    readonly baseOctaves: 3.5;
+    readonly freezeOctaves: 4.2;
+    readonly capFactor: 10;
+    readonly settleP: 0.999;
+    readonly settleV: 0.02;
+};
 /** Widget/FBO/port budgets (design-004 §2 host pipeline, §3 FBO pool, §6 port materialization; ported into design-005 §4 engine facade). */
 export declare const RUNTIME_BUDGETS: {
     readonly keepMountedWidgets: 256;

package/dist/types/packages/core/src/settings/ground-config.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Ground-layer (P0) pass configs — CANONICAL home (2026-07-16, the @ice/ground
+ * extraction): plain data shared by the ground renderer, the react facade's
+ * `grid` prop, and apps. They live in core because core is the vocabulary
+ * package every layer may import (ground cannot import react; react cannot
+ * import ground — design-002 §6). Values are verbatim from the original
+ * renderers: GridConfig from v1 GridRenderer.ts:5-35 (tuned to Apple
+ * Freeform / FigJam), wires + snap-guides from their 2026 dom reflectors.
+ */
+export interface GridConfig {
+    /** World-unit spacings for up to 3 grid levels [fine, medium, coarse]. */
+    spacings: [number, number, number];
+    /** Dot RGB color as [r, g, b] in 0-1 range. */
+    dotColor: [number, number, number];
+    /** Base dot opacity multiplier (0-1). */
+    dotAlpha: number;
+    /** CSS-pixel range where a grid level fades in: [start, end]. */
+    fadeIn: [number, number];
+    /** CSS-pixel range where a grid level fades out: [start, end]. */
+    fadeOut: [number, number];
+    /** Dot radius range in CSS pixels [min, max]. Scaled by DPR internally. */
+    dotRadius: [number, number];
+    /** Per-level opacity weight: level i gets (base + i * step). */
+    levelWeight: [number, number];
+}
+/** Verbatim from v1 GridRenderer.ts:27-35 (Apple Freeform / FigJam feel). */
+export declare const DEFAULT_GRID_CONFIG: GridConfig;
+/** Minimal-neutral wire styling (design-004 §6: chrome is subdued; wires defer to content). */
+export interface WiresConfig {
+    /** Default wire stroke (CSS color). */
+    wireColor: string;
+    /** Accent stroke for a Selected wire. */
+    selectedColor: string;
+    wireWidth: number;
+    selectedWidth: number;
+    /** Materialized-port dot radius (CSS px) + colors (idle vs during a connect drag). */
+    portRadius: number;
+    portColor: string;
+    portActiveColor: string;
+}
+export declare const DEFAULT_WIRES_CONFIG: WiresConfig;
+/** v1 `DEFAULT_SNAP_GUIDE_CONFIG` (SnapGuideRenderer.ts), field for field. */
+export interface SnapGuidesConfig {
+    /** Guide line + spacing bar color as [r, g, b] in 0-1 range. */
+    color: [number, number, number];
+    /** Stroke width in screen px (constant across zoom). */
+    lineWidth: number;
+    /** Alignment-line alpha. */
+    guideAlpha: number;
+    /** Equal-spacing bar alpha. */
+    spacingAlpha: number;
+    /** End-tick half-length in screen px (v1 shader barHeight). */
+    tickPx: number;
+}
+export declare const DEFAULT_SNAP_GUIDES_CONFIG: SnapGuidesConfig;

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

@@ -7,6 +7,10 @@
  *   `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).
  *
  *   HANDLE PICKING (the point of the design): handles carry a world AABB, so the
  *   `react`-phase `spatialSync` indexes them automatically and `picking` resolves
@@ -43,6 +47,6 @@
  *   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";
+import type { TickSystem, World } from "@vibecook/strata-ecs";
 export declare function createSelectionChromeSystem(world: World): TickSystem;
-export declare function createBreakpointSystem(_world: World): System;
+export declare function createBreakpointSystem(world: World): TickSystem;

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

@@ -0,0 +1,25 @@
+/**
+ * The insert-ghost reap (cleanup phase; catalog/insert.ts, 2026-07-19).
+ *
+ * Three exits for a tray-insert ghost, all owned here so nothing transient
+ * crosses frames unaccounted (design-002 §2 cleanup law):
+ *
+ *  - PROMOTED (`GhostCommitted`, set by moveBehavior at the create commit):
+ *    despawned ONE tick after the commit — the projected twin lands at the
+ *    NEXT sync, so waiting one tick makes the swap happen inside a single
+ *    reflect flush (twin mounts, ghost unmounts, same frame — no blink).
+ *    Selection rides the same beat: the doc sink parked the twin ids in its
+ *    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.
+ *
+ *  - RETIRING (`GhostRetiring`, cancel / rejected drop): despawned when the
+ *    fly-back `TransformTween` lands (camera-sim removes it on arrival).
+ *
+ *  - STRANDED (no Grab, no tween, no live recognizer still capturing it): a
+ *    clean click on a tray tile (the drag never formed), or an integrity
+ *    cancel that raced the claim. Despawned silently — it never left the
+ *    press point under the tray.
+ */
+import type { System, World } from "@vibecook/strata-ecs";
+export declare function createInsertGhostReap(world: World): System;

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

@@ -5,13 +5,26 @@
  *
  * `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.
+ * TICK system so the body runs every frame — it is the writer that bumps
+ * `SpatialVersion` — but as of strata 0.7.0 (petition 7 LANDED) the body is
+ * O(delta), not O(N): a `world.changes` collector journals exactly which
+ * entities were touched (Position/Size writes, Active/WidgetEquipped flips,
+ * spawns, destroys — same-frame, drained INSIDE the pipeline), and each is
+ * re-checked against `isIndexable` → upsert or remove. The 2026-07-13 walk
+ * machinery (last-known AABB cache, compare-and-skip, generation sweep) is
+ * RETIRED — the collector knows; the system no longer has to discover.
+ *
+ * The FULL WALK survives as exactly what petition 7 said it should be:
+ *  - the SEED (a collector only journals writes made after its creation);
+ *  - the `reset` route (world.reset / replace import / nav `clearCaches`);
+ *  - the `coarse` fallback (some declared-raw-write system touched
+ *    Position/Size rows the journal cannot attribute — rescan, never miss).
+ * Nav gating rides the walk QUERIES at archetype level: widgets match
+ * `[Position, Size, WidgetEquipped, Active]`, chrome matches
+ * `[Position, Size, Not(WidgetEquipped)]` — the union is exactly
+ * `Position+Size ∧ (¬WidgetEquipped ∨ Active)`, and `isIndexable` is the
+ * same predicate entity-wise for the delta path. 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
@@ -24,10 +37,11 @@
  *                      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.
+ * Pick priority is plane priority: HandleSpec chrome first, then widgets
+ * topmost by sibling order (petition 8 — the shared SiblingOrderIndex feeds
+ * 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.
  */
 import type { Entity, System, TickSystem, World } from "@vibecook/strata-ecs";
 import { SpatialIndex } from "@ice/kernel";

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

@@ -13,10 +13,16 @@
  *                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).
+ * All timing reads FrameInfo.CLOCK — the accumulated CLAMPED-dt gesture clock
+ * (2026-07-17, supersedes both raw FrameInfo.now and the 2026-07-12
+ * event-timestamp anchor): rAF `now` lags wall time by up to SECONDS under
+ * throttling/headless/software rendering while event.timeStamp does not, so
+ * any window mixing the two evaluates garbage; `clock` is monotonic, stalls
+ * contribute ≤ dtClampMs (the stall-protection intent), and no event
+ * timestamp ever enters window math. 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";

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

@@ -5,15 +5,17 @@
  * 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.
+ * restore from riders — Position AND sibling order (petition 8: a forgotten
+ * order restore leaves the sequence diverged forever, the old StackZ law);
+ * 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).
+ *   no DropTarget → COMMIT (final Position per live Drags edge + the sibling
+ *     placement as ORDER ops, so one gesture stays one transaction).
  * Without dropSystem installed no DropTarget ever exists ⇒ plain commits.
  */
 import type { System, World } from "@vibecook/strata-ecs";

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

@@ -7,9 +7,13 @@
  * 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).
+ * dragged set, `Grab` per widget with the CURRENT Position/Size + the ORDER
+ * MEMO embedded (petition 8: ChildOf parent, nearest non-dragged predecessor
+ * sibling, original sibling index), and the sibling elevate — `moveRelation(w,
+ * ChildOf, "last")`, frame-scoped, equivalent to the old global-top within the
+ * frame; part of the gesture divergence, restored from the memo on cancel.
+ * Edge-less widgets (legacy/runtime world) skip both memo and elevate — the
+ * move would be a strata no-op and there is no sequence to restore.
  *
  * `resizeClaim` (JustActive × RoutedResize): `Drags` + `Grab` over the Selected
  * ∧ Resizable set; the anchor lives on the captured handle's `HandleSpec` — no

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

@@ -3,7 +3,9 @@
  * 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
+ * `Container` widgets (∉dragged), pick the topmost by sibling order (petition
+ * 8 — compareStackOrder, the SAME comparator pick/paint use, so the drop
+ * candidate can never diverge from what the user sees on top), 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

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

@@ -7,7 +7,9 @@
  * 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
+ * preserve aspect (corner handles). Min size clamps to the target widget's
+ * `defineWidget` `minSize` (via `PrefabId`), or 1×1 for non-widget resizables.
+ * `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).

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

@@ -6,14 +6,32 @@
  * 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
+ * spatial index (rect query = intended bounds ∪ VIEWPORT, expanded by
+ * threshold — design-003 §5.2: a distant same-axis edge IN VIEW must
+ * contribute a guide, the Figma behavior; the widgetlab field check 2026-07-16
+ * caught the intended-rect-only query never seeing a card 115px above the
+ * drag). Filtered to `SnapTarget ∧ ¬Culled ∧ ∉dragged` — ¬Culled is the
+ * design's "Visible" scoping in cull-less rigs too (no cull system ⇒ nothing
+ * is Culled ⇒ all candidates pass). 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.
+ * adds it to the absolute write). SnapState clears to 0,0 when snap is off / no
+ * source / no candidate.
+ *
+ * GUIDE CHROME (design-003 §6, as-built 2026-07-16 — the once-deferred half):
+ * the kernel result's `guides`/`spacings` become pooled runtime `GuideLine` /
+ * `SpacingBar` entities the P0 snap-guides reflector draws (design-004 §1
+ * amendment: ground stratum, under content — James's call). Pool mechanics
+ * mirror selectionChrome: a TICK system (exactly one pass per frame — spawn/
+ * destroy are not idempotent, and the pool must reap on the frame the last
+ * snapping drag ENDS, when the recognizer query is empty), `ctx.spawn` on
+ * grow, `ctx.destroy` on shrink, change-only `edit().set` in steady state
+ * (same guide held across frames ⇒ zero writes). Alignment guides write
+ * `from = to = 0` — the full-viewport sentinel (v1's full-canvas lines);
+ * spacing indicators flatten one entity per segment (v1 `u_spacings` parity).
+ * No silent caps: the pool grows to whatever the kernel returns (v1's
+ * MAX_GUIDES=16 truncation is banned).
  */
-import type { Entity, System, World } from "@vibecook/strata-ecs";
+import type { Entity, TickSystem, World } from "@vibecook/strata-ecs";
 import { type SpatialIndex } from "@ice/kernel";
-export declare function createSnapSystem(world: World, index: SpatialIndex<Entity>): System;
+export declare function createSnapSystem(world: World, index: SpatialIndex<Entity>): TickSystem;

package/dist/types/packages/core/src/systems/nav-flight.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Nav-flight — the T1 camera-flight half of design-006 (portal zoom).
+ *
+ * CUT-FIRST, THEN FLY (§3): the nav ops perform the ECS cut synchronously
+ * (frame switch, membership resweep, index rebuild) and then hand presentation
+ * to this slice — `startNavFlight` snaps the camera to the continuity-solved
+ * start `c0` and arms the `NavTransition` resource; the `navFlight` tick
+ * system (simulate, beside cameraInertia) advances a closed-form critically-
+ * damped progress spring each frame and writes the camera along the log-zoom
+ * path until rest. The transition is PURE PRESENTATION: killing it at any
+ * moment leaves a fully consistent world in the destination frame.
+ *
+ * - `NavTransition` is a RESOURCE, not closure state (the CameraInertia
+ *   pattern: devtools sees it, no hidden singleton — design-003 §9). Resources
+ *   cannot be removed, so `active` is the liveness flag; `epoch` bumps on
+ *   every (re)start so the T2 reflector can distinguish retarget from resume.
+ * - Camera writes are UNCLAMPED (design-006 §3.1): flight paths transit far
+ *   outside the user-gesture zoom band; only the ARRIVAL camera (clamped by
+ *   the nav op) bounds where the flight rests.
+ * - Gestures always win (§4): any active camera gesture — `Camera.gesturing`,
+ *   stamped by cameraControl in ctl:behave, i.e. EARLIER this same frame —
+ *   deactivates the flight without touching the camera.
+ * - The portal affine (`as/aox/aoy`, departed-frame → destination-frame) and
+ *   `frozen` ride the resource for T2's departing-plane reflector; T1's camera
+ *   math only needs c0/c1.
+ */
+import type { TickSystem, World } from "@vibecook/strata-ecs";
+import type { CameraState, PortalAffine } from "@ice/kernel";
+/** The one in-flight nav transition (design-006 §3.1). Inactive = at rest. */
+export declare const NavTransition: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly active: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"enter" | "exit">, true>;
+    /** Progress spring state (closed-form critically damped, kernel springStep). */
+    readonly p: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly v: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    /** Depth-capped flight — T2 presents it as a crossfade, not geometry (§5). */
+    readonly frozen: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    /** Bumps on every flight start; T2 distinguishes retarget from resume. */
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /** Response multiplier from octave distance (locked at start; §4). */
+    readonly durMul: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly c0x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c0y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c0z: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c1x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c1y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c1z: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    /** Portal affine A: departed-frame coords → destination-frame coords (T2). */
+    readonly as: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly aox: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly aoy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>, {
+    readonly active: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"enter" | "exit">, true>;
+    /** Progress spring state (closed-form critically damped, kernel springStep). */
+    readonly p: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly v: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    /** Depth-capped flight — T2 presents it as a crossfade, not geometry (§5). */
+    readonly frozen: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    /** Bumps on every flight start; T2 distinguishes retarget from resume. */
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /** Response multiplier from octave distance (locked at start; §4). */
+    readonly durMul: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly c0x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c0y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c0z: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c1x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c1y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly c1z: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    /** Portal affine A: departed-frame coords → destination-frame coords (T2). */
+    readonly as: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly aox: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly aoy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;
+/**
+ * Arm a flight from the already-cut world: continuity-solve was done by the
+ * caller (`exact` = c0 in destination-frame coords), the arrival `c1` is
+ * already clamped. Applies the depth cap (§5), snaps the camera to c0, and
+ * activates the resource. Callers guarantee a live Viewport — headless/no-
+ * viewport paths snap to the arrival instead and never reach here.
+ */
+export declare function startNavFlight(world: World, kind: "enter" | "exit", A: PortalAffine, exact: CameraState, c1: CameraState): void;
+/** Deactivate without touching the camera (integrity pops, gesture yields). */
+export declare function abortNavFlight(world: World): void;
+/**
+ * Is a nav flight driving the camera right now? THE gate for flight-time
+ * GPU/paint duty (design-006 §8.2, answered by field testing 2026-07-16):
+ * heavy-motion consumers treat `Camera.gesturing ∨ navFlightActive` as one
+ * "camera in transient motion" signal — composite DPR drop, band-repaint
+ * suppression, Hot-island freeze, breakpoint retier deferral. `gesturing`
+ * itself stays a pure user-gesture fact (the inertia precedent): flights
+ * never stamp it, consumers OR the two.
+ */
+export declare function navFlightActive(world: World): boolean;
+export declare function createNavFlight(world: World): TickSystem;

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

@@ -20,6 +20,12 @@ export interface WidgetInteraction {
     readonly solid?: boolean;
     /** "longPress": hold-to-lift dragging (iOS home-screen model); default "press". */
     readonly dragOn?: "press" | "longPress";
+    /**
+     * UE-Blueprint comment-box drag (2026-07-18): a move claim on this widget
+     * also claims every widget FULLY INSIDE its bounds at claim time (spatial
+     * membership — never reparenting). Default false.
+     */
+    readonly sweepContained?: boolean;
 }
 export interface WidgetDef {
     readonly type: string;
@@ -34,6 +40,16 @@ export interface WidgetDef {
     readonly surface: WidgetSurface;
     /** Framework component (opaque to core — the react package narrows it). */
     readonly component: unknown;
+    /**
+     * GL only: a DOM chrome component portaled into the widget's CONTENT-plane
+     * host (P1), which stacks UNDER the GL canvas (P2) — v1's proven
+     * CardChrome-beneath-the-canvas sandwich. The island renders ONLY the 3D
+     * content; the card body (gradient, radius, ring, shadow, lift spring,
+     * hover/overlap glow) is DOM and shares the app's CSS with DOM widgets.
+     * Opaque to core — the react package narrows it. Ignored for dom-surface
+     * widgets (their component IS the chrome).
+     */
+    readonly chrome?: unknown;
     readonly sizeMode?: SizeMode;
     readonly defaultSize?: {
         readonly w: number;
@@ -57,6 +73,23 @@ export interface WidgetDef {
      * the compatibility key list the connect gesture checks.
      */
     readonly ports?: readonly WidgetPortDecl[];
+    /**
+     * Palette/tray preview (design-005 §2 amendment, 2026-07-19). ENGINE-FREE
+     * BY CONTRACT: a preview renders with no world, no entity, no ops — a pure
+     * picture the host mounts inert (that is what makes it portable: trays,
+     * docs sites, a widget store). Authored at `defaultSize`; hosts scale.
+     * Three tiers, least effort first:
+     *  - absent            → the REAL component mounts with default props in
+     *                        the framework's preview sandbox (dom surfaces;
+     *                        truthful by construction);
+     *  - `{ props: {…} }`  → same sandbox mount with curated props;
+     *  - a component, or `{ component }` → author-owned preview (a static
+     *    mockup, a live self-ticking clock — the author's call). In P1 all
+     *    declared previews are DOM components — the sanctioned escape hatch
+     *    for GL widgets too (P2 adds the r3f snapshot pipeline).
+     * Opaque to core — the react package narrows it (`component` precedent).
+     */
+    readonly preview?: unknown;
     readonly container?: {
         readonly accepts: readonly string[];
         readonly provides?: readonly string[];
@@ -96,6 +129,8 @@ export interface WidgetType {
     readonly propToGroup: Readonly<Record<string, string>>;
     readonly surface: WidgetSurface;
     readonly component: unknown;
+    /** GL widgets: DOM chrome under the canvas (see WidgetDef.chrome). */
+    readonly chrome: unknown;
     readonly sizeMode: SizeMode;
     readonly defaultSize: {
         readonly w: number;
@@ -112,6 +147,10 @@ export interface WidgetType {
     /** Runtime capability tags the equip system stamps at projection. */
     readonly capabilityTags: readonly Tag[];
     readonly migrate: Readonly<Record<number, (prev: Record<string, unknown>) => Record<string, unknown>>>;
+    /** Normalized author preview component (opaque; react narrows). null = none declared. */
+    readonly previewComponent: unknown;
+    /** Prop overrides for the default real-component preview mount (validated names). */
+    readonly previewProps?: Readonly<Record<string, unknown>>;
 }
 /** Stamped by the equip system once a projected widget carries its capability tags. */
 export declare const WidgetEquipped: Tag;