@vibecook/ice 0.10.0 → 0.14.0

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

@@ -1,69 +0,0 @@
-/**
- * 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/dom/src/measure-adapter.d.ts

@@ -1,31 +0,0 @@
-/**
- * The measurement adapter (design-004 §2 host pipeline; measure side).
- *
- * Wraps a `ResizeObserver` over auto-sized widgets' CONTENT elements and pushes
- * `{ entity, w, h }` samples into the engine's {@link MeasureQueue} — the
- * adapter-only path (Law 2: adapters ONLY enqueue; `measureIngest` turns samples
- * into `MeasuredSize` facts inside the frame contract). It resolves an entity's
- * content element on demand via the caller's `hostFor` (the widget host reflector
- * owns the element↔entity mapping).
- *
- * §2 hidden-measure rule: a `display:none` host collapses to `0×0`, and a
- * full→0 sample would pass any dead-band and corrupt bounds/cull on re-entry —
- * so the adapter NEVER enqueues while the host is hidden (computed `display:none`
- * / no `offsetParent`), and also drops a literal `0×0`. It is the CALLER's job to
- * re-`observe` (or otherwise force a remeasure) on re-show — a `ResizeObserver`
- * does not re-fire for an element that was hidden and shown at the same box size.
- *
- * One shared `ResizeObserver` multiplexes every observed element (fewer objects,
- * identical semantics to one-per-element); `element → entity` maps a callback
- * entry back to its widget.
- */
-import type { Entity, MeasureQueue } from "../../core/src/index";
-export interface MeasureAdapter {
-    /** Begin observing the entity's content element (no-op if `hostFor` yields none). */
-    observe(entity: Entity): void;
-    /** Stop observing the entity's content element. */
-    unobserve(entity: Entity): void;
-    /** Disconnect the observer and drop all mappings. */
-    dispose(): void;
-}
-export declare function attachMeasureAdapter(hostFor: (e: Entity) => HTMLElement | undefined, queue: MeasureQueue): MeasureAdapter;

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

@@ -1,49 +0,0 @@
-/**
- * Measurement wiring (design-004 §2 host pipeline; measure side, the store half).
- *
- * `attachMeasureAdapter` owns the `ResizeObserver` and the element→entity
- * mapping; THIS module owns *when* to observe/unobserve, driven by the engine's
- * widget mount store. It subscribes and reconciles each snapshot diff into four
- * transitions (design-004 §2 / decision 4):
- *
- *  - **fresh mount + visible** → `observe` (the RO fires its own first sample);
- *  - **visible → hidden** (culled-but-kept-mounted) → `unobserve` (disconnect on
- *    hide — a `display:none` host measures `0×0` and a full→0 sample corrupts
- *    bounds/cull on re-entry);
- *  - **hidden → shown** → re-`observe` AND a FORCED synchronous re-measure: a
- *    `ResizeObserver` does not re-fire for an element hidden and shown at the
- *    same box size, so the reconnect alone would leave the rider stale;
- *  - **unmount** (exits the snapshot) → `unobserve`.
- *
- * Ordering note: the mount store notifies from the widget-runtime flush
- * reflector, which is registered BEFORE the `domWidgets` host reflector — so at
- * notify time the host `<div>` for a just-mounted (or just-shown) widget may not
- * exist / may still be `display:none`. Like the React portal hook (which defers
- * via its own scheduler), this defers the reconcile to a microtask so it runs
- * AFTER the whole synchronous reflector pass, by which point `domWidgets` has
- * created/unhidden the host and `hostFor` + the forced re-measure see a real box.
- *
- * Law 2 holds: everything here only enqueues (through the adapter or the forced
- * sample) — no world writes, no ECS reads.
- */
-import type { Entity, MeasureQueue, WidgetMountStore } from "../../core/src/index";
-/** The element source (the `domWidgets` reflector supplies this via `hostFor`). */
-export interface MeasureWiringHosts {
-    hostFor(entity: Entity): HTMLElement | undefined;
-}
-export interface MeasureWiringOpts {
-    /**
-     * 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;
-        h: number;
-    };
-}
-/**
- * Begin observing auto-sized widget hosts against `store`, pushing measurements
- * into `queue` (drained by `measureIngest`). Returns a teardown that
- * unsubscribes and disposes the underlying `ResizeObserver`.
- */
-export declare function wireMeasurement(store: WidgetMountStore, hosts: MeasureWiringHosts, queue: MeasureQueue, opts?: MeasureWiringOpts): () => void;

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

@@ -1,33 +0,0 @@
-/**
- * The lifted plane (design-004 §1, planes P1/P3 — M6 slice).
- *
- * M3 stood up ONE camera-transformed content plane (`host.ts`, P1). M6 adds P3,
- * the **lifted** plane: a second transform-origin-0-0 div appended to the
- * container AFTER the content plane, so it stacks ABOVE it (P3 over P1) with no
- * z-index bookkeeping — DOM order is the strata order (§1: "stacking is
- * stratified"). Both planes take the SAME single camera transform (the
- * plane-transform reflector writes both), so a promoted widget re-parented
- * content→lifted keeps its world position; it just paints above the content
- * layer for the duration of the drag.
- *
- * `createCanvasHost` is intentionally untouched: the content plane it owns is
- * the P1 authority. `createPlanes` is additive — it borrows that content plane
- * and mints the lifted sibling next to it.
- */
-import type { CanvasHost } from "./host";
-/** The two DOM planes M6 addresses: P1 content (host-owned) + P3 lifted. */
-export interface Planes {
-    /** P1: the host's camera-transformed content plane; world-positioned hosts mount here. */
-    readonly content: HTMLDivElement;
-    /** P3: camera-transformed, stacked above content; promoted (dragged) hosts re-parent here. */
-    readonly lifted: HTMLDivElement;
-    /** Remove the lifted plane (the content plane is the host's — host.dispose reaps it). */
-    dispose(): void;
-}
-/**
- * Mint the lifted plane next to the host's content plane. The lifted div is
- * appended to the container AFTER the content plane, so it renders above it
- * (P3 > P1). Returns both planes for the plane-transform reflector (writes both)
- * and the dom-widgets reflector (re-parents hosts between them on drag-promote).
- */
-export declare function createPlanes(host: CanvasHost): Planes;

package/dist/types/packages/dom/src/reflectors/chrome.d.ts

@@ -1,33 +0,0 @@
-/**
- * The chrome reflector (design-004 §5 chrome plane P4; post-notify, SCREEN-space).
- *
- * Draws the engine's pooled chrome entities plus the out-of-ECS marquee buffer
- * into a dedicated, non-transformed overlay plane above the content plane:
- *  - each `SelectionBox` entity → a 1px outline rect (its world x,y,w,h mapped to
- *    screen via `worldToScreen` × zoom);
- *  - each `HandleSpec` entity → an 8×8 screen-px square CENTERED on the handle's
- *    world AABB center (the handle's world size is zoom-scaled for picking; the
- *    drawn size is screen-constant);
- *  - the `marqueeBuffer.rect` (world) → a rect while non-null.
- *
- * P4 is screen-space by design (design-004 §2 rescope): unlike the content plane
- * (one camera transform), chrome is recomputed per camera change — small N. This
- * reflector therefore reads the `Camera` resource directly (an acknowledged
- * small-N screen-space camera consumer).
- *
- * `always: true`, not observer-driven: the marquee buffer has no ECS stamp to
- * observe, so the reflector must get a chance every frame. A cheap early-out
- * keeps it idle-free — it returns immediately when there is nothing to draw AND
- * nothing was drawn last frame (so a cleared selection still gets one flush to
- * remove its nodes). Style writes are change-only (per-node geometry cache) and
- * counted by `writes()` — the churn instrument, mirroring the other reflectors.
- *
- * Law 10: reflectors write output only, never read layout or write ECS — this
- * flush touches only the overlay plane's node styles.
- */
-import { type MarqueeBuffer, type ReflectorDef, type World } from "../../../core/src/index";
-import type { CanvasHost } from "../host";
-export declare function createChromeReflector(host: CanvasHost, _world: World, marqueeBuffer: MarqueeBuffer): ReflectorDef & {
-    writes(): number;
-    dispose(): void;
-};

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

@@ -1,59 +0,0 @@
-/**
- * The DOM widget HOST reflector (design-004 §2 host pipeline; design-002 §5
- * `domWidgets`).
- *
- * This is the reflector-owned HALF of the widget runtime: it reconciles a host
- * `<div>` per mounted widget against the engine's mount store and paints its
- * world-unit geometry. The OTHER half — the React portal list — is owned by a
- * hook subscribed to the SAME store (design-004 §2, decision 3); this file never
- * touches React. Each host carries an inner `data-ice-content` element that the
- * portal targets, so the two halves meet only at that node.
- *
- * Store, not query: membership (enter/exit) and the culled-but-kept-mounted
- * `hidden` flag are ENGINE-side decisions (cull + keep-mounted LRU, mount-store.ts)
- * published through a `useSyncExternalStore` snapshot. That store has NO ECS stamp
- * for a reflector `observe` to watch, so — like the cursor reflector — this one is
- * `always: true` and does its own cheap dirt detection:
- *  - **membership**: `store.getSnapshot()` identity is O(1); the snapshot changes
- *    IFF membership or a hidden flag changed, so an unchanged snapshot skips the
- *    reconcile entirely;
- *  - **geometry**: a private observer on `[Position, Size]` sets a dirty flag, so
- *    the (change-only) geometry pass runs only when a widget actually moved/resized
- *    — a still scene touches no DOM. Effective size is `MeasuredSize` where present
- *    and non-zero, else `Size` (design-004 §2). (MeasuredSize changes ride a
- *    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
- *    PRESERVES the React portal — the portal targets the content node, and moving a
- *    portal's container node does not remount it, so widget React state survives the
- *    lift. While ANY host is lifted, every host's content element is inerted
- *    (`pointer-events: none`, the pinned inert-during-drag contract, design-004 §4).
- *
- * Law 10: reflectors run post-notify, write output only, never read layout or
- * write ECS — this flush touches only host `<div>` style/attributes/parentage.
- */
-import { type Entity, type ReflectorDef, type WidgetMountStore, type World } from "../../../core/src/index";
-/** The two planes a host can live in (design-004 §1: P1 content, P3 lifted). */
-export interface DomWidgetsHost {
-    readonly contentPlane: HTMLElement;
-    readonly liftedPlane: HTMLElement;
-}
-export interface DomWidgetsReflector extends ReflectorDef {
-    /** The entity's content element (the `data-ice-content` portal target), or undefined if not hosted. */
-    hostFor(entity: Entity): HTMLElement | undefined;
-    /** Live host count (= mounted widgets, visible + kept-mounted). */
-    hostCount(): number;
-    /** Geometry writes so far — one per enter, one per changed host, zero for unchanged (churn instrument). */
-    geometryWrites(): number;
-    /** Tear down the private observers (call when unregistering the reflector before the world dies). */
-    dispose(): void;
-}
-export declare function createDomWidgetsReflector(host: DomWidgetsHost, world: World, store: WidgetMountStore): DomWidgetsReflector;

package/dist/types/packages/dom/src/reflectors/graybox.d.ts

@@ -1,31 +0,0 @@
-/**
- * The gray-box reflector (design-002 §5 reflector doctrine; M3 exit gate).
- *
- * A minimal enter/update/exit reconciler: it mirrors every `Position` + `Size`
- * entity to an absolutely-positioned div inside the content plane, laying each
- * out in WORLD units (`left/top/width/height` in world coordinates) — the
- * plane's single camera transform (see plane-transform.ts) does the screen
- * mapping, so this reflector never touches the camera and never reads layout
- * (Law 10). It is the stand-in for real widget rendering until the widget
- * runtime lands (M4+); "gray box" = deterministic per-entity fill, no content.
- *
- * Reconciliation, dirty-driven on the `Position`/`Size` query (design-002 §5):
- *  - enter: create a div (fill hashed from the entity handle), write geometry,
- *    stage it in a DocumentFragment (one plane append per flush — 10k mounts do
- *    not thrash layout);
- *  - update: compare against a per-entity geometry cache and rewrite ONLY the
- *    entities whose world geometry actually changed;
- *  - exit: remove divs for entities absent from this flush.
- *
- * `styleWrites()` counts entities whose geometry was (re)written this flush (one
- * per enter, one per changed entity, zero for unchanged) — the churn instrument
- * the M3 tests assert: change one entity ⇒ exactly one style write. `nodeCount()`
- * is the live div count. Because the reflector is dirty-driven, a static frame
- * does not flush at all, so neither counter moves.
- */
-import { type ReflectorDef } from "../../../core/src/index";
-import type { CanvasHost } from "../host";
-export declare function createGrayboxReflector(host: CanvasHost): ReflectorDef & {
-    styleWrites(): number;
-    nodeCount(): number;
-};

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

@@ -1,38 +0,0 @@
-/**
- * The plane-transform reflector (design-002 §5 `planeTransform`; M3 exit gate,
- * widened for the M6 lifted plane).
- *
- * Observes the `Camera` RESOURCE and nothing else. Each flush reads the camera,
- * derives the ONE per-plane CSS transform via kernel `planeCssTransform` (the
- * sole owner of that math — Law 13), and writes it to EVERY camera-transformed
- * DOM plane in a SINGLE `style.transform` assignment each. Panning the whole
- * canvas is therefore O(1) in the DOM: one transform write per plane per moving
- * frame, independent of node count — the property that makes an infinite canvas
- * of 10k gray boxes pan at frame rate.
- *
- * The input is widened to `{ contentPlane; liftedPlane? }` (design-004 §1: P1 +
- * P3 share the one camera). A `CanvasHost` still satisfies it structurally, so
- * M3 callers are unchanged; M6 passes both planes and the lifted plane (P3)
- * tracks the content plane (P1) exactly, so a promoted widget keeps its world
- * position across the content→lifted re-parent.
- *
- * `transformWrites()` is the M3 instrument: because the reflector is dirty-
- * driven on the Camera resource (equality-suppressed — design-002 §5), a static
- * camera flushes zero times and the counter stays flat; every distinct camera
- * value bumps it exactly once. The frame-contract tests assert both halves.
- *
- * Law 10: reflectors run post-notify, write output only, and NEVER read layout
- * or write ECS — this flush touches only `host.contentPlane.style`.
- */
-import { type ReflectorDef } from "../../../core/src/index";
-/**
- * The camera-transformed DOM plane(s). A `CanvasHost` satisfies this
- * structurally (M3 backward compat); M6 passes `liftedPlane` too so P3 tracks P1.
- */
-export interface CameraPlanes {
-    readonly contentPlane: HTMLElement;
-    readonly liftedPlane?: HTMLElement;
-}
-export declare function createPlaneTransformReflector(host: CameraPlanes): ReflectorDef & {
-    transformWrites(): number;
-};

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

@@ -1,69 +0,0 @@
-/**
- * @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 "../../core/src/index";
-import { type GroundLayerHost, type GroundReflector } from "./layer";
-import type { GroundPass } from "./pass";
-import type { ReadSpatial } from "./passes/magnet-collect";
-import type { PoleSource } from "./poles";
-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 { cursorVisualPoles, localPointerPoles, type Pole, type PoleSource } from "./poles";
-export { collectMagnetLevels, collectMagnetSources, magnetFieldScale, resolveMagnet, MAX_MAGNET_SOURCES, type MagnetLevel, type ReadSpatial, } from "./passes/magnet-collect";
-export { DEFAULT_GRID_CONFIG, DEFAULT_GRID_MAGNET_CONFIG, DEFAULT_SNAP_GUIDES_CONFIG, DEFAULT_WIRES_CONFIG, type GridConfig, type GridMagnetConfig, type SnapGuidesConfig, type WiresConfig, } from "../../core/src/index";
-export interface GroundContext {
-    readonly host: GroundLayerHost;
-    readonly world: World;
-    /** Connect-drag preview reader (graph boards); omit on boards without wires. */
-    readonly readWirePreview?: () => WirePreviewBuffer;
-    /**
-     * Broad-phase reader over the ONE spatial index (design-010 §3.2, the
-     * readWirePreview precedent) — the magnet grid's widget sources. Facades
-     * wire `stack.index.search`; omit ⇒ magnet renders a pole-only field.
-     */
-    readonly readSpatial?: ReadSpatial;
-}
-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>;
-    /**
-     * Magnet pole sources (design-010 §3.3) — live app-authored objects, so they
-     * live HERE, not in the plain-data GridConfig. Nothing wired ⇒ the magnet
-     * field (if enabled) is widget-only; with magnet off they cost one gated
-     * no-op subscription each.
-     */
-    readonly poles?: PoleSource | readonly PoleSource[];
-    /** 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

@@ -1,40 +0,0 @@
-/**
- * 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 "../../core/src/index";
-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

@@ -1,41 +0,0 @@
-/**
- * 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 "../../core/src/index";
-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-classic.d.ts

@@ -1,30 +0,0 @@
-/**
- * The CLASSIC dot-grid renderer — extracted VERBATIM from grid.ts when the
- * magnet mode arrived (design-010 D1: classic stays the default and the
- * pixel-exact baseline; the pass facade in grid.ts owns mode switching).
- *
- * 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 "../../../core/src/index";
-import { Mesh } from "three/webgpu";
-import type { GroundFrame } from "../pass";
-export interface ClassicGridRenderer {
-    readonly mesh: Mesh;
-    /** Layer-written each collect. */
-    setCamera(frame: GroundFrame): void;
-    /** Config-written (the configure seam). */
-    configure(cfg: GridConfig): void;
-    dispose(): void;
-}
-export declare function createClassicGrid(cfg: GridConfig): ClassicGridRenderer;

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

@@ -1,31 +0,0 @@
-/**
- * The MAGNET grid renderer — TSL port of vibe-field draft/magnet-grid's
- * `magnet.wgsl` (design-010 §5). Three instanced-quad meshes (one per lattice
- * level) whose vertex stage reconstructs sites from `instanceIndex`, evaluates
- * the field (superposition of rounded-box SDF sources; poles are DEGENERATE
- * boxes with half = 0, r = 0 — D3), and shapes the glyph (needle orients
- * along the field; dot swells with |field|).
- *
- * Deltas from the WGSL, per design-010:
- *  - ONE source buffer (storage, read-only, `setPBO` for the WebGL fallback —
- *    D4); the mouse uniform / `mouseOn` branch are deleted.
- *  - fade ladder, level weight and dotAlpha are CPU-baked into ONE per-level
- *    alpha (they are per-level constants per frame — magnet-collect owns them).
- *  - dot rest radius comes from `GridConfig.dotRadius[0]` (config continuity
- *    with the classic grid), not the WGSL's hardcoded `halfLen·0.16`.
- *  - coincidence skip (§5.4): sites shared with a visible coarser level drop
- *    out (integer spacing ratios), replicating the classic max-composite look.
- *  - NDC is computed from CSS-px directly (the WGSL path) — glyph sizes are
- *    CSS px, DPR rides the viewport; the layer's ortho camera is bypassed.
- */
-import type { GridConfig, GridMagnetConfig } from "../../../core/src/index";
-import { Group } from "three/webgpu";
-import type { GroundFrame } from "../pass";
-import { type MagnetLevel } from "./magnet-collect";
-export interface MagnetGridRenderer {
-    readonly group: Group;
-    /** Rewrite every uniform + the source buffer from this frame's collect. */
-    update(frame: GroundFrame, cfg: GridConfig, magnet: GridMagnetConfig, levels: readonly MagnetLevel[], sources: Float32Array, sourceCount: number): void;
-    dispose(): void;
-}
-export declare function createMagnetGrid(): MagnetGridRenderer;

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

@@ -1,28 +0,0 @@
-/**
- * The grid pass — a MODE FACADE since design-010: the classic analytic dot
- * grid (grid-classic.ts, the default — byte-identical to pre-magnet builds)
- * and the magnet field lattice (grid-magnet.ts + magnet-collect.ts) behind
- * ONE `GridPass` contract. `configure` deep-merges the `magnet` key one level
- * (§3.1) so partial re-tunes never clobber the block.
- *
- * Wake graph (all magnet wakes gated on `enabled` — the idle-scene zero-frame
- * guarantee is untouched when off): camera/resize are layer-owned;
- * `SpatialVersion` re-collects widget sources (gated on `widgets` too);
- * injected pole sources wake through their own subscriptions (D5 — the pass
- * observes no pointer/cursor/presence vocabulary). The magnet renderer is
- * built LAZILY on first enable: classic-only apps pay zero magnet cost.
- */
-import { type GridConfig } from "../../../core/src/index";
-import type { GroundPass } from "../pass";
-import type { PoleSource } from "../poles";
-import { type ReadSpatial } from "./magnet-collect";
-export interface GridPass extends GroundPass {
-    /** Live re-tune (the react `grid` prop seam) — partial merge over current values. */
-    configure(cfg: Partial<GridConfig>): void;
-}
-/** Injected magnet inputs (design-010 §3.2) — absent pieces disable their sources. */
-export interface GridPassDeps {
-    readonly poles?: readonly PoleSource[];
-    readonly readSpatial?: ReadSpatial;
-}
-export declare function createGridPass(initial?: Partial<GridConfig>, deps?: GridPassDeps): GridPass;

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

@@ -1,14 +0,0 @@
-/**
- * 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 "../../../core/src/index";
-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

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