@vibecook/ice 0.1.0 → 0.2.0

package/dist/types/packages/devtools/src/dock.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The devtools dock — ONE draggable window hosting all three tools
+ * (2026-07-13, James: "make the 3 tools into one draggable panel").
+ *
+ * strata's observer + profiler and our GL panel each mount `position: fixed`
+ * into their own corner. The dock does NOT re-implement any of them (standing
+ * rule: wrap first-party tools): it is a fixed, draggable shell with three
+ * stacked slots; each tool mounts into its slot via its own `container`
+ * option, and dock-scoped CSS de-windows them (`position: static`, full
+ * width, no border/shadow) so they read as sections of one panel. Their own
+ * behavior is untouched — the observer keeps its tabs/collapse/vertical
+ * resize (its header drag goes inert: left/top are ignored at static), the
+ * profiler + GL strips keep their click-to-expand.
+ *
+ * Slot order is fixed by the dock, not by mount order: profiler and GL are
+ * one-line summary strips, the observer is the deep-dive — strips on top.
+ * Layout (x/y/width/open) persists to localStorage, same as the observer:
+ * schema edits full-reload the page by design; the dock must stay put.
+ */
+export type DockCorner = "tl" | "tr" | "bl" | "br";
+export type DockSlotId = "profiler" | "gl" | "observer";
+export interface DockOptions {
+    /** Where the dock mounts (default: document.body). */
+    readonly container?: HTMLElement;
+    /** Initial corner when nothing is persisted yet (default "tr"). */
+    readonly corner?: DockCorner;
+    /** Header title (default "ice devtools"). */
+    readonly title?: string;
+    /** Initial width in px when nothing is persisted yet (default 420). */
+    readonly width?: number;
+}
+export interface Dock {
+    readonly el: HTMLElement;
+    /** The mount element for one tool. Empty slots are display:none via CSS. */
+    slot(id: DockSlotId): HTMLElement;
+    dispose(): void;
+}
+export declare function createDock(opts?: DockOptions): Dock;

package/dist/types/packages/devtools/src/gl-panel.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The GL metrics panel — the engine-specific renderer readout strata has no
+ * counterpart for (2026-07-13, James: "comprehensive r3f profiler ... and our
+ * engine specific optimization metrics ... with nice visuals").
+ *
+ * Pure DOM, strata's visual language (same palette/typography as the observer
+ * + profiler HUD so the three read as one toolset). Fed by pushes of
+ * `GlPanelStats` — the STRUCTURAL MIRROR of @ice/r3f's `GlFrameStats`
+ * (devtools cannot import r3f under the walls; keep the shapes aligned):
+ *
+ *   head      fps · gpu ms + a gpu sparkline against the frame budget
+ *   frame     cpu / gpu bars vs budget, with session maxima
+ *   render    draw calls · triangles · points/lines · programs · geoms · textures
+ *   virtual   live render targets + total resolution, FBO bytes vs budget,
+ *   textures  the island phase census as a segmented bar, repaint/evict counters
+ *   lod       zoom → hysteresis band → effective DPR, live targets per band
+ *   widgets   Visible vs Culled population
+ *
+ * All values land via `textContent` (never innerHTML with data). Rendering is
+ * throttled — pushes arrive per composited frame, the DOM refreshes at ~8 Hz.
+ */
+/** Mirror of @ice/r3f `GlFrameStats` (structural — see the header). */
+export interface GlPanelStats {
+    readonly cpuMs: number;
+    readonly gpuMs: number;
+    readonly fps: number;
+    readonly drawCalls: number;
+    readonly triangles: number;
+    readonly points: number;
+    readonly lines: number;
+    readonly programs: number;
+    readonly geometries: number;
+    readonly textures: number;
+    readonly renderTargets: number;
+    readonly renderMegaPixels: number;
+    readonly fboBytes: number;
+    readonly fboBudgetBytes: number;
+    readonly islands: {
+        readonly total: number;
+        readonly hot: number;
+        readonly warm: number;
+        readonly waking: number;
+        readonly cold: number;
+        readonly dormant: number;
+    };
+    readonly bandHistogram: Readonly<Record<string, number>>;
+    readonly repainted: number;
+    readonly pendingPaints: number;
+    readonly evicted: number;
+    readonly zoom: number;
+    readonly band: number;
+    readonly effectiveDpr: number;
+    readonly visibleWidgets: number;
+    readonly culledWidgets: number;
+}
+export type GlPanelCorner = "tl" | "tr" | "bl" | "br";
+export interface GlPanelOptions {
+    readonly container?: HTMLElement;
+    readonly corner?: GlPanelCorner;
+    /** Frame budget in ms — the sparkline's reference line (default 16.7). */
+    readonly budgetMs?: number;
+    /** Start with the detail body open (default false). */
+    readonly expanded?: boolean;
+}
+export interface GlPanel {
+    push(stats: GlPanelStats): void;
+    dispose(): void;
+}
+export declare function createGlPanel(opts?: GlPanelOptions): GlPanel;

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

@@ -1,8 +1,10 @@
 /**
- * @ice/devtools — the engine devtools panel (design-005 §4): pointers/recognizers,
- * planes, sovereignty badges, loop telemetry. A standalone DOM panel that reads
- * the world outside the tick — it is NOT a reflector and writes no ECS.
- * Import wall: @ice/core (+kernel) only; nobody imports us (depcruise-enforced).
+ * @ice/devtools — strata's observer panel + FPS profiler, engine-flavored
+ * (describe/durable/ephemeral/reflect-lane glue). Reads the world outside the
+ * tick; never a reflector, never writes ECS. Nobody imports us
+ * (depcruise-enforced leaf).
  */
-export declare const DEVTOOLS_VERSION = "0.0.0";
-export { attachDevtools, type DevtoolsHandle, type DevtoolsOpts } from "./panel";
+export declare const DEVTOOLS_VERSION = "0.1.0";
+export { attachDevtools, engineDescribe, type DevtoolsEngine, type DevtoolsHandle, type DevtoolsOpts, } from "./attach";
+export { createDock, type Dock, type DockCorner, type DockOptions, type DockSlotId } from "./dock";
+export { createGlPanel, type GlPanel, type GlPanelCorner, type GlPanelOptions, type GlPanelStats } from "./gl-panel";

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

@@ -9,11 +9,9 @@ export { createPlaneTransformReflector, type CameraPlanes } from "./reflectors/p
 export { createGrayboxReflector } from "./reflectors/graybox";
 export { createDomWidgetsReflector, type DomWidgetsHost, type DomWidgetsReflector, } from "./reflectors/dom-widgets";
 export { startRafLoop } from "./loop";
-export { attachPointerAdapter, type GLRoute, type PointerAdapterOpts } from "./pointer-adapter";
+export { attachPointerAdapter, type GLRoute, type GLRouteVerdict, type PointerAdapterOpts } from "./pointer-adapter";
 export { createCursorReflector } from "./reflectors/cursor";
 export { createRemoteCursorsReflector, type RemoteCursorsReflector } from "./reflectors/remote-cursors";
-export { createGridReflector, DEFAULT_GRID_CONFIG, type GridConfig } from "./reflectors/grid";
-export { createWiresReflector, DEFAULT_WIRES_CONFIG, type WirePreview, type WiresConfig, type WiresReflector, } from "./reflectors/wires";
 export { createChromeReflector } from "./reflectors/chrome";
 export { attachMeasureAdapter, type MeasureAdapter } from "./measure-adapter";
 export { wireMeasurement, type MeasureWiringHosts, type MeasureWiringOpts } from "./measure-wiring";

package/dist/types/packages/dom/src/measure-wiring.d.ts

@@ -33,8 +33,8 @@ export interface MeasureWiringHosts {
 }
 export interface MeasureWiringOpts {
     /**
-     * Border-box read for the forced re-measure on show. Defaults to
-     * `getBoundingClientRect`; tests inject a deterministic stub.
+     * Border-box read for the forced re-measure on show. Defaults to layout
+     * `offsetWidth`/`offsetHeight`; tests inject a deterministic stub.
      */
     readonly measure?: (el: HTMLElement) => {
         w: number;

package/dist/types/packages/dom/src/pointer-adapter.d.ts

@@ -28,6 +28,15 @@
  * through L0). `stopPropagation()` inside widget content is the OTHER boundary:
  * a stopped event never reaches the container listener, so it never becomes a
  * canvas fact at all — that is the design, not a gap.
+ *
+ * Hover-time amendment (design-002 §8, 2026-07-18): down/move facts ALSO carry
+ * `overInteractive` — the same `crossesInteractive` check, run at hover time,
+ * OR'd with the GL router's hover verdict — so the world can telegraph the
+ * opt-out BEFORE a down (cursor affordances). It never gates gestures:
+ * `surfaceHandled` stays down-only and keeps its exact meaning. During a
+ * container-captured drag every event retargets to the container, so
+ * `overInteractive` reads false mid-gesture — correct: the gesture owns the
+ * pointer, not the widget under it.
  */
 import { type InputQueue } from "@ice/core";
 import type { CanvasHost } from "./host";
@@ -41,7 +50,18 @@ import type { CanvasHost } from "./host";
  * recognizers skip it via `HandledByWidget` — the same contract as the
  * native-interactive opt-out.
  */
-export type GLRoute = (kind: "down" | "move" | "up" | "cancel", screenX: number, screenY: number, native: PointerEvent) => boolean;
+export type GLRoute = (kind: "down" | "move" | "up" | "cancel", screenX: number, screenY: number, native: PointerEvent) => boolean | GLRouteVerdict;
+/**
+ * The richer GL verdict (hover-time amendment, 2026-07-18): `handled` keeps the
+ * boolean's exact meaning (island content claimed the event); `overInteractive`
+ * adds the hover fact — the pick chain holds claim-capable content (a mesh with
+ * a down/click handler), so a down HERE would be the island's. Plain `boolean`
+ * returns stay legal (≡ `{ handled }`), so existing routes never break.
+ */
+export interface GLRouteVerdict {
+    readonly handled: boolean;
+    readonly overInteractive?: boolean;
+}
 export interface PointerAdapterOpts {
     readonly glRoute?: GLRoute;
 }

package/dist/types/packages/dom/src/reflectors/dom-widgets.d.ts

@@ -24,6 +24,11 @@
  *    dedicated observer; the note below is historical:
  *    picked up on the next Position/Size stamp or membership change; the ResizeObserver
  *    measurement path — a later slice — will arm its own dirt.)
+ *  - **opacity**: a private observer on `[Opacity]` (attach/detach/value) sets a
+ *    dirty flag; the change-only pass writes `style.opacity` on the host (absent
+ *    component = 1 = property cleared). The GL twin is the composite quad's
+ *    `uOpacity` — a gl widget's host here carries only its DOM chrome, so the
+ *    two halves fade from the same cell.
  *  - **drag-promote** (P3): a private observer on `[Grab]` membership sets a dirty
  *    flag; a host whose entity holds `Grab` re-parents content→lifted plane and back
  *    on release. Re-parenting MOVES the host node (with its content child), which

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

@@ -0,0 +1,52 @@
+/**
+ * @ice/ground — the P0 ground stratum as ONE WebGPU canvas (design-004 §1
+ * as-built amendment, 2026-07-16). three's WebGPURenderer + TSL, WebGL2
+ * fallback automatic. Off the react chain: react receives the layer as an
+ * OPAQUE factory (`<InfiniteCanvas ground={ground(...)}>`); imperative apps
+ * register `layer.reflector` themselves. Passes: dot grid, wires, snap
+ * guides — future ground shaders/effects join the same pass registry.
+ * (Selection chrome moved OFF the ground 2026-07-17: rings live with the
+ * cards, the multi-select union box is P4 dom chrome — always on top.)
+ */
+import type { GridConfig, SnapGuidesConfig, WirePreviewBuffer, WiresConfig, World } from "@ice/core";
+import { type GroundLayerHost, type GroundReflector } from "./layer";
+import type { GroundPass } from "./pass";
+import { type GroundRendererLike } from "./renderer";
+export type { GroundFrame, GroundPass } from "./pass";
+export type { GroundReflector } from "./layer";
+export type { GroundRendererLike } from "./renderer";
+export { SoupBuilder, parseCssColor, type Rgba, type TriSoup } from "./passes/soup-collect";
+export { collectGuides } from "./passes/guides-collect";
+export { collectWires } from "./passes/wires-collect";
+export { DEFAULT_GRID_CONFIG, DEFAULT_SNAP_GUIDES_CONFIG, DEFAULT_WIRES_CONFIG, type GridConfig, type SnapGuidesConfig, type WiresConfig, } from "@ice/core";
+export interface GroundContext {
+    readonly host: GroundLayerHost;
+    readonly world: World;
+    /** Connect-drag preview reader (graph boards); omit on boards without wires. */
+    readonly readWirePreview?: () => WirePreviewBuffer;
+}
+export interface GroundLayer {
+    readonly reflector: GroundReflector;
+    /** Live grid re-tune (the react `grid` prop forwards here). */
+    configureGrid(cfg: Partial<GridConfig>): void;
+    dispose(): void;
+}
+export interface GroundOptions {
+    readonly grid?: Partial<GridConfig>;
+    readonly wires?: Partial<WiresConfig>;
+    readonly guides?: Partial<SnapGuidesConfig>;
+    /** Extra app passes, rendered after the built-ins (renderOrder ≥ 3 is yours). */
+    readonly passes?: readonly GroundPass[];
+    /** Force the WebGL2 backend (debug / e2e A-B runs). */
+    readonly forceWebGL?: boolean;
+    /** TEST seam: inject a fake renderer (headless orchestration tests). */
+    readonly rendererOverride?: GroundRendererLike;
+}
+export type GroundFactory = (ctx: GroundContext) => GroundLayer;
+/**
+ * Build the ground layer factory. Usage:
+ *   react apps:      <InfiniteCanvas ground={ground({ grid: {...} })} …>
+ *   imperative apps: const layer = ground()( { host, world, readWirePreview } );
+ *                    engine.registerReflector(layer.reflector);
+ */
+export declare function ground(opts?: GroundOptions): GroundFactory;

package/dist/types/packages/ground/src/layer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The ground LAYER — one reflector, one canvas, one render (design-004 §1
+ * as-built 2026-07-16: P0 consolidated from three stacked canvases into a
+ * single WebGPU canvas; grid, wires and snap-guides are now PASSES of this
+ * layer, and future ground effects join the same registry).
+ *
+ * Coordinate model: the layer renders in SCREEN CSS-px space — an ortho
+ * camera maps [0..w]×[0..h] (y-down) to clip, and passes build their geometry
+ * through the kernel `worldToScreen` seam per collect (the proven 2D-canvas
+ * semantics: geometry rebuilds on the same dirt that re-stroked the old
+ * canvases; the grid stays a per-pixel screen-space shader). The Y-flip
+ * question never arises here — `worldToScreen` IS the one conversion (L13).
+ *
+ * Reflector contract (design-002 §5): post-notify, output-only, never reads
+ * layout in flush (the ResizeObserver owns sizing), never writes ECS.
+ * `always: true` with a private dirty union — an idle scene renders zero
+ * frames; ANY dirty pass re-renders the whole canvas (one draw, same cost
+ * class as a pan frame under the old grid). WebGPU init is async: flushes
+ * before ready are deferred (flags stay armed), the first ready flush paints.
+ */
+import { type ReflectorDef, type World } from "@ice/core";
+import type { GroundPass } from "./pass";
+import type { GroundRendererLike } from "./renderer";
+export interface GroundLayerHost {
+    readonly container: HTMLElement;
+    readonly contentPlane: HTMLElement;
+}
+export interface GroundReflector extends ReflectorDef {
+    /** False while init is pending or after a device/context failure. */
+    available(): boolean;
+    /** Whole-canvas renders so far (the churn instrument — 0 on an idle scene). */
+    redraws(): number;
+}
+export interface GroundLayerInternals {
+    reflector: GroundReflector;
+    /** Wake every pass + render (config changes, external invalidation). */
+    invalidateAll(): void;
+    dispose(): void;
+}
+export declare function createLayer(host: GroundLayerHost, world: World, renderer: GroundRendererLike, passes: readonly GroundPass[]): GroundLayerInternals;

package/dist/types/packages/ground/src/pass.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The ground-pass contract (design-004 §1, as-built 2026-07-16: P0 is ONE
+ * WebGPU canvas; passes are its draw layers).
+ *
+ * A pass owns a scene `object` (mesh/group with a TSL node material), arms its
+ * own dirty observers, and rebuilds its geometry/uniforms in `collect` — PURE
+ * world reads in the layer's SCREEN-px coordinate space (the ortho camera maps
+ * CSS px → clip; world→screen goes through the kernel `worldToScreen` seam,
+ * Law 13). Heavy per-pass math (tessellation, triangle-soup emission) lives in
+ * sibling `*-collect.ts` modules that import ONLY core/kernel, so collectors
+ * unit-test under happy-dom with no GPU and no three import.
+ */
+import type { World } from "@ice/core";
+import type { Object3D } from "three/webgpu";
+/** Per-flush frame facts every pass collects against. */
+export interface GroundFrame {
+    /** CSS-px viewport size. */
+    readonly width: number;
+    readonly height: number;
+    readonly dpr: number;
+    /** Engine camera: world top-left + zoom (grid.ts P0 contract). */
+    readonly camera: {
+        readonly x: number;
+        readonly y: number;
+        readonly zoom: number;
+    };
+}
+export interface GroundPass {
+    readonly name: string;
+    /** The pass's scene object; the layer adds it once and disposes with the pass. */
+    readonly object: Object3D;
+    /**
+     * Arm dirty observers on the world; `wake()` marks this pass for a
+     * re-collect on the next flush. Camera/resize dirt is LAYER-owned (it wakes
+     * every pass) — arm only pass-specific sources here. Returns unsubscribers.
+     */
+    arm(world: World, wake: () => void): Array<() => void>;
+    /** Rebuild geometry/uniforms from the world (read-only; screen-px space). */
+    collect(world: World, frame: GroundFrame): void;
+    dispose(): void;
+}

package/dist/types/packages/ground/src/passes/grid.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The dot-grid pass — TSL port of the raw-WebGL grid (itself verbatim from v1
+ * GridRenderer.ts; the fragment math below is that shader re-expressed as a
+ * node graph, level loop unrolled in JS). Screen-space: a fullscreen triangle
+ * whose vertex stage passes clip coords through; the fragment reconstructs
+ * world position from `screenCoordinate` (top-left device px on BOTH backends
+ * — three normalizes, so the old manual y-flip is gone) + camera uniforms.
+ *
+ * One deliberate re-expression: the GLSL if/else fade ladder became the
+ * closed form `clamp(min(rise, fall), 0, 1)` — identical piecewise output
+ * (rise 0→1 across fadeIn, plateau 1, fall 1→0 across fadeOut) with no
+ * branching. Everything else (fract-distance dots, 0.5-device-px AA,
+ * max-composited levels) matches term for term.
+ */
+import { type GridConfig } from "@ice/core";
+import type { GroundPass } from "../pass";
+export interface GridPass extends GroundPass {
+    /** Live re-tune (the react `grid` prop seam) — partial merge over current values. */
+    configure(cfg: Partial<GridConfig>): void;
+}
+export declare function createGridPass(initial?: Partial<GridConfig>): GridPass;

package/dist/types/packages/ground/src/passes/guides-collect.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Snap-guides collector — the pure ECS→triangles half of the guides pass
+ * (v1 SnapGuideRenderer look, carried over from the 2D-canvas reflector it
+ * replaces): full-viewport magenta alignment lines (`GuideLine.from == to` ⇒
+ * full span — design-003 §6), bounded spans, and equal-spacing bars with 4px
+ * end ticks. Screen-px output via the kernel `worldToScreen` seam. NO guide
+ * count caps (the pool grows; so does the soup).
+ */
+import { type SnapGuidesConfig, type World } from "@ice/core";
+import type { GroundFrame } from "../pass";
+import { type TriSoup } from "./soup-collect";
+export declare const guideQ: import("@vibecook/strata-ecs").Query;
+export declare const barQ: import("@vibecook/strata-ecs").Query;
+export declare function collectGuides(world: World, frame: GroundFrame, config?: SnapGuidesConfig): TriSoup;

package/dist/types/packages/ground/src/passes/guides.d.ts

@@ -0,0 +1,3 @@
+import { type SnapGuidesConfig } from "@ice/core";
+import type { GroundPass } from "../pass";
+export declare function createGuidesPass(initial?: Partial<SnapGuidesConfig>): GroundPass;

package/dist/types/packages/ground/src/passes/soup-collect.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Triangle-soup builders — the PURE half of the geometry passes (no three
+ * import; unit-tested under happy-dom). Collectors emit screen-px triangles
+ * with per-vertex rgba into a growable soup; the three-side `soup-mesh`
+ * uploads them. MSAA (renderer antialias) smooths edges, matching the old 2D
+ * canvases' stroke AA closely enough at 1–2 px widths.
+ */
+export interface TriSoup {
+    /** xyz per vertex (z = 0 — the layer renders flat in screen space). */
+    positions: Float32Array;
+    /** rgba per vertex, 0-1. */
+    colors: Float32Array;
+    vertexCount: number;
+}
+export type Rgba = readonly [number, number, number, number];
+export declare class SoupBuilder {
+    private pos;
+    private col;
+    private vert;
+    /** Axis-aligned rect (two triangles). */
+    rect(x: number, y: number, w: number, h: number, c: Rgba): void;
+    /** Stroke segment (a→b) of `width`, flat caps — a quad across the segment normal. */
+    segment(ax: number, ay: number, bx: number, by: number, width: number, c: Rgba): void;
+    /** Stroke a polyline (interleaved xy) as per-segment quads (smooth-curve joins). */
+    polyline(points: ArrayLike<number>, width: number, c: Rgba): void;
+    /** Filled disc as a triangle fan (MSAA smooths the rim; 16 segs ≈ round at ≤8 px). */
+    disc(cx: number, cy: number, r: number, c: Rgba, segments?: number): void;
+    build(): TriSoup;
+}
+/**
+ * `rgba(r, g, b, a)` / `rgb(…)` / `#rrggbb` → [r,g,b,a] 0-1 (the WiresConfig
+ * colors are CSS strings — v1/2D-canvas heritage). Unknown formats fall back
+ * to opaque mid-gray rather than throwing in a reflector path.
+ */
+export declare function parseCssColor(css: string): Rgba;

package/dist/types/packages/ground/src/passes/soup-mesh.d.ts

@@ -0,0 +1,8 @@
+import { Mesh } from "three/webgpu";
+import type { TriSoup } from "./soup-collect";
+export interface SoupMesh {
+    readonly mesh: Mesh;
+    update(soup: TriSoup): void;
+    dispose(): void;
+}
+export declare function createSoupMesh(renderOrder: number): SoupMesh;

package/dist/types/packages/ground/src/passes/wires-collect.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Wires collector — the pure ECS→triangles half of the wires pass. Port of
+ * the 2D-canvas wires reflector's drawing, kernel-tessellated:
+ *
+ * - Wire geometry NEVER reads a port ENTITY (design-001 §5.3): endpoints
+ *   resolve from the wire's `WireFrom`/`WireTo` widgets + `WirePorts` ids
+ *   against the type registry's static port schema (core `portSlots` — the
+ *   old local resolver's TODO, retired), so a CULLED endpoint still draws.
+ * - Cubics build in WORLD space then map control points through the kernel
+ *   `worldToScreen` seam — bezier curves are affine-invariant, so the mapped
+ *   cubic IS the screen curve — and `tessellateCubic` (0.25 px tolerance)
+ *   flattens with density that tracks zoom for free.
+ * - Connect preview: solid when snapped-compatible, dashed [6,4] otherwise
+ *   (dash placement from the tessellation's arc-length prefix).
+ * - Materialized port dots: triangle-fan discs, active color while any
+ *   connect drag is routed.
+ */
+import { type WirePreviewBuffer, type WiresConfig, type World } from "@ice/core";
+import type { GroundFrame } from "../pass";
+import { type TriSoup } from "./soup-collect";
+export declare const wireQ: import("@vibecook/strata-ecs").Query;
+export declare const geometryQ: import("@vibecook/strata-ecs").Query;
+export declare const measuredQ: import("@vibecook/strata-ecs").Query;
+export declare const selectedQ: import("@vibecook/strata-ecs").Query;
+export declare const portQ: import("@vibecook/strata-ecs").Query;
+export declare const routedConnectQ: import("@vibecook/strata-ecs").Query;
+/** A live connect drag moves the preview every frame — Drag value dirt covers it. */
+export declare const connectDragQ: import("@vibecook/strata-ecs").Query;
+/** Nav churn signal: Active membership flips re-collect (scope filter below). */
+export declare const activeQ: import("@vibecook/strata-ecs").Query;
+export declare function collectWires(world: World, frame: GroundFrame, config?: WiresConfig, preview?: WirePreviewBuffer): TriSoup;

package/dist/types/packages/ground/src/passes/wires.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Wires pass — the three-side wrapper over the pure `collectWires` (renders
+ * above the grid, below the guides, matching the old P0 canvas order).
+ * Dirt mirrors the old 2D reflector's observers; the connect preview rides
+ * `[RoutedConnect, Drag]` value dirt (the buffer updates exactly when the
+ * connect recognizer's Drag advances) instead of a per-frame value diff.
+ */
+import { type WirePreviewBuffer, type WiresConfig } from "@ice/core";
+import type { GroundPass } from "../pass";
+export declare function createWiresPass(initial?: Partial<WiresConfig>, readPreview?: () => WirePreviewBuffer): GroundPass;

package/dist/types/packages/ground/src/renderer.d.ts

@@ -0,0 +1,15 @@
+import type { Camera, Scene } from "three/webgpu";
+/** The layer's renderer seam — tests inject a fake (compositor `GlLike` precedent). */
+export interface GroundRendererLike {
+    readonly canvas: HTMLCanvasElement;
+    ready(): boolean;
+    failed(): boolean;
+    /** Register a one-shot "became ready" callback (fires immediately if already ready). */
+    onReady(cb: () => void): void;
+    setSize(cssW: number, cssH: number, dpr: number): void;
+    render(scene: Scene, camera: Camera): void;
+    dispose(): void;
+}
+export declare function createGroundRenderer(doc: Document, opts?: {
+    forceWebGL?: boolean;
+}): GroundRendererLike;

package/dist/types/packages/ice/src/ground.d.ts

@@ -0,0 +1 @@
+export * from "../../ground/src/index";

package/dist/types/packages/kernel/src/bezier.d.ts

@@ -29,6 +29,21 @@ export declare function cubicPoint(c: Cubic, t: number): Vec2;
  * culling/picking prefilters.
  */
 export declare function cubicAABB(c: Cubic): AABB;
+export interface Tessellation {
+    /** Flattened polyline, interleaved [x0,y0, x1,y1, …] in the cubic's own space. */
+    points: Float32Array;
+    /** Cumulative arc length at each polyline point (same unit; [0] = 0). */
+    arcLength: Float32Array;
+}
+/**
+ * Adaptive cubic flattening + prefix arc length (2026-07-16, the @ice/ground
+ * wires pass: stroke tessellation and dash placement both ride this). Emit
+ * density follows curvature — flat spans emit one segment regardless of
+ * length; tolerance is in the cubic's OWN space (the ground renderer passes
+ * screen-px cubics with ~0.25 px tolerance, so density tracks zoom for free).
+ * `maxDepth` bounds pathological inputs (2^depth segments worst case).
+ */
+export declare function tessellateCubic(c: Cubic, tolerance?: number, maxDepth?: number): Tessellation;
 /** Distance from a point to a line segment. */
 export declare function distanceToSegment(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
 /**

package/dist/types/packages/kernel/src/coords.d.ts

@@ -26,6 +26,21 @@ export declare function worldToScreen(worldX: number, worldY: number, camera: Ca
  * Returns the new camera (does not mutate). Clamping is the caller's policy.
  */
 export declare function zoomAtPoint(camera: CameraState, screenX: number, screenY: number, newZoom: number): CameraState;
+/**
+ * The DEFAULT framing camera (2026-07-18, James: "do zoom to fit, but with a
+ * upper and bottom cap … should feel natural"): zoom-to-fit `content` (a
+ * world-space bbox) with `pad` px of breathing room on every side, zoom
+ * clamped into [minZoom, maxZoom] — the natural band: never so far in that
+ * one small card fills the screen, never so far out that the board turns
+ * into an ant farm. The content CENTER stays centered whether or not a cap
+ * engages. Callers own the band policy (engine default: FIT_DEFAULTS ∩ the
+ * session's hard CameraLimits) and must pass a real viewport.
+ */
+export declare function fitCamera(content: Rect, vpW: number, vpH: number, opts: {
+    pad: number;
+    minZoom: number;
+    maxZoom: number;
+}): CameraState;
 /**
  * Camera → the ONE per-plane CSS transform (design-002 §5 `planeTransform`).
  * Children are laid out in WORLD units inside the plane (left/top = world x/y),

package/dist/types/packages/kernel/src/easing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CSS-style cubic-bezier timing functions (pure math — kernel).
+ *
+ * `cubicBezierEase(x1, y1, x2, y2)` builds f(t): the exact curve CSS
+ * `transition-timing-function: cubic-bezier(…)` runs, so GL surfaces can
+ * match DOM transitions beat-for-beat (the composite-quad lift mirrors the
+ * DOM card lift's spring, cubic-bezier(0.2, 0.9, 0.3, 1.2)). y outside [0,1]
+ * (overshoot springs) is legal and expected; x1/x2 are clamped to [0,1] per
+ * spec so x(u) stays monotone and invertible.
+ */
+export declare function cubicBezierEase(x1: number, y1: number, x2: number, y2: number): (t: number) => number;

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

@@ -11,3 +11,6 @@ export * from "./zoom-bands";
 export * from "./eviction";
 export * from "./anchors";
 export * from "./bezier";
+export * from "./easing";
+export * from "./nav-flight";
+export * from "./layout";