@vibecook/ice 0.10.0 → 0.14.0

package/dist/types/packages/r3f/src/gl-root.d.ts

@@ -1,96 +0,0 @@
-import { type ReactElement } from "react";
-import { type Texture } from "three";
-import { type Engine, type WidgetMountStore } from "../../core/src/index";
-import type { GLBridge } from "./bridge";
-export interface GLViewsProps {
-    readonly engine: Engine;
-    readonly bridge: GLBridge;
-    readonly store: WidgetMountStore;
-    /** FBO byte budget (default `RUNTIME_BUDGETS.fboBytes`, 256 MB). */
-    readonly maxFboBytes?: number;
-    /** Repaint stagger per composited frame (v1 default 4). */
-    readonly maxRepaintsPerFrame?: number;
-    /**
-     * Ambient-animation rate cap (default 60; `Infinity` = uncapped). Applies
-     * ONLY to self-sustained frames — Hot islands and stagger backlogs park the
-     * loop between paints instead of spinning at native refresh (5 Hot islands
-     * at 120 Hz dpr-2 measured 96 % GPU duty at idle, 2026-07-14). Lift eases
-     * and externally invalidated frames (camera, drags, props dirt) still run
-     * at display rate. Approximate: frames land on the vsync grid.
-     */
-    readonly maxAnimationFps?: number;
-    /**
-     * Idle paint-DPR ceiling (default 1.5; `Infinity` = uncapped): island FBOs
-     * allocate at `min(pixelRatio, maxPaintDpr) × band`. On dpr-2 displays the
-     * composite's bilinear upscale from 1.5× is visually indistinguishable
-     * (2026-07-14 A/B) and cuts Hot repaint cost ~22 %.
-     */
-    readonly maxPaintDpr?: number;
-    /**
-     * Shared IBL: stamped as `scene.environment` on EVERY island's private
-     * scene (arrival/change repaints all islands). Load it app-side (e.g.
-     * drei's useEnvironment in a Suspense boundary) — undefined until then is
-     * fine; islands paint unlit-by-IBL and repaint when it lands.
-     */
-    readonly environment?: Texture | null;
-    /**
-     * GL frame profiling (2026-07-13): fires once per composited frame with the
-     * pass's real costs. CPU/counts/pass-shape are engine-measured every
-     * profiled frame; GPU ms rides stats-gl's headless `StatsProfiler`
-     * (EXT_disjoint_timer_query / WebGPU timestamps — 0 where unsupported, e.g.
-     * Safari without its flag), DYNAMICALLY imported on first use so the
-     * dependency costs nothing when profiling is off. Feed the numbers to the
-     * devtools profiler HUD as lanes (`devtools.lane("gpu", s.gpuMs)`).
-     */
-    readonly onFrameStats?: (stats: GlFrameStats) => void;
-}
-/**
- * One profiled composite frame — see {@link GLViewsProps.onFrameStats}.
- * MIRRORED structurally as `GlPanelStats` in @ice/devtools (which cannot
- * import r3f under the walls) — keep the shapes aligned.
- */
-export interface GlFrameStats {
-    /** Whole-pass main-thread ms (reconcile + island paints + composite). */
-    readonly cpuMs: number;
-    /** GPU ms summed across the pass's render calls (0 until queries resolve / unsupported). */
-    readonly gpuMs: number;
-    /** stats-gl smoothed fps (0 until the profiler is live). */
-    readonly fps: number;
-    /** `renderer.info` aggregated across ALL of this pass's render calls. */
-    readonly drawCalls: number;
-    readonly triangles: number;
-    readonly points: number;
-    readonly lines: number;
-    /** Live compiled shader programs (renderer-lifetime, not per-frame). */
-    readonly programs: number;
-    readonly geometries: number;
-    readonly textures: number;
-    /** Virtual texturing: live island render targets + their summed resolution. */
-    readonly renderTargets: number;
-    readonly renderMegaPixels: number;
-    readonly fboBytes: number;
-    readonly fboBudgetBytes: number;
-    /** Island phase census (the demand/retention state machine, design-004 §3/§7). */
-    readonly islands: {
-        readonly total: number;
-        readonly hot: number;
-        readonly warm: number;
-        readonly waking: number;
-        readonly cold: number;
-        readonly dormant: number;
-    };
-    /** Live targets per painted zoom band ("×1", "×0.5", …) — the LOD downgrade census. */
-    readonly bandHistogram: Readonly<Record<string, number>>;
-    /** This pass's shape (PassStats). */
-    readonly repainted: number;
-    readonly pendingPaints: number;
-    readonly evicted: number;
-    /** LOD context: camera zoom → hysteresis band → the DPR new paints get. */
-    readonly zoom: number;
-    readonly band: number;
-    readonly effectiveDpr: number;
-    /** Scene population: Visible vs Culled widgets (all surfaces). */
-    readonly visibleWidgets: number;
-    readonly culledWidgets: number;
-}
-export declare function GLViews({ engine, bridge, store, maxFboBytes, maxRepaintsPerFrame, maxAnimationFps, maxPaintDpr, environment, onFrameStats, }: GLViewsProps): ReactElement;

package/dist/types/packages/r3f/src/gl-router.d.ts

@@ -1,70 +0,0 @@
-/**
- * The pointer router's GL path (design-004 §4, rev 2 corrected).
- *
- * At EVENT time (outside the tick — world reads are verified-unrestricted)
- * the router runs its own synchronous point-pick against THE spatial index
- * via core's `pickTopAt` — the identical narrow-phase the in-tick `picking`
- * system runs, so the two can never disagree. It does NOT consult last-frame
- * `Targets`: that relation is absent for a touch's first event (the pointer
- * entity doesn't exist yet at down) and stale for fast mouse crossings —
- * rev 1 of the design ate the first tap on every interactive GL widget.
- * `Targets` remains the in-tick authority; this pick is a routing decision,
- * not a second truth.
- *
- * Hit a GL-view widget → island-local convert (kernel, THE Y-flip) → raycast
- * the island's scene through its ortho camera → dispatch synthetic events to
- * the intersected objects' R3F handlers. A handler calling
- * `stopPropagation()` claims the event: the adapter flags the fact
- * `surfaceHandled` and recognizers skip it (`HandledByWidget`, the M4 spine).
- *
- * Capture semantics (per island): a claimed down captures the pointer — its
- * moves/ups go to that island until up/cancel, mirroring how DOM widget
- * content holds `setPointerCapture` for sustained interactions. Hover
- * enter/leave are synthesized from pick transitions on buttonless moves.
- *
- * R3F-INTERNAL-ADJACENT (the one acknowledged spot, implementation-plan
- * risks): handlers are read from `object.__r3f.handlers` — the instance
- * state R3F v9 attaches to every declaratively-created three object. No
- * other R3F internal is touched; the dispatcher owns its own event shape.
- * Mid-event ordering note (design-004 §4): handlers may run engine ops —
- * legal; such mutations land immediately while the same event's position
- * facts land next tick via the queue.
- */
-import { type Intersection, type Object3D } from "three";
-import type { SpatialIndex } from "../../kernel/src/index";
-import { type Entity, type World } from "../../core/src/index";
-import type { GLBridge } from "./bridge";
-/** The synthetic event island handlers receive (R3F-handler-compatible core). */
-export interface IslandPointerEvent {
-    readonly type: string;
-    readonly nativeEvent: PointerEvent;
-    /** Island-local intersection point (three world = island space). */
-    readonly point: Intersection["point"] | undefined;
-    readonly distance: number;
-    readonly object: Object3D;
-    readonly eventObject: Object3D;
-    readonly intersections: readonly Intersection[];
-    readonly entity: Entity;
-    stopPropagation(): void;
-    readonly stopped: boolean;
-}
-export interface GLPointerRouterDeps {
-    readonly world: World;
-    readonly bridge: GLBridge;
-    readonly index: SpatialIndex<Entity>;
-}
-export interface GLPointerRouter {
-    /** The adapter's `glRoute` seam. True = island content claimed the event. */
-    route(kind: "down" | "move" | "up" | "cancel", screenX: number, screenY: number, native: PointerEvent): boolean;
-    /**
-     * Hover-time verdict as of the LAST routed `move` (design-002 §8 amendment,
-     * 2026-07-18): the pick chain under the pointer holds claim-capable island
-     * content — a mesh whose handlers include `onPointerDown`/`onClick` (the
-     * claim/click paths; hover-only handlers like the shapes swarm's move reader
-     * do NOT count — they never opt a down out). True for the whole life of an
-     * island capture. Feed it into the adapter's `GLRouteVerdict.overInteractive`
-     * on moves; presentation truth only, never a routing input.
-     */
-    overInteractive(): boolean;
-}
-export declare function createGLPointerRouter({ world, bridge, index }: GLPointerRouterDeps): GLPointerRouter;

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

@@ -1,17 +0,0 @@
-/**
- * @ice/r3f — R3F islands + the virtual-texture compositor (design-004 §3–4).
- * The ONLY package that touches three/@react-three (as peers). Top of the
- * chain: r3f → react → dom → core → kernel.
- */
-export { createGLBridge, type GLBridge, type GLBridgeOpts, type IslandHandle, type IslandFrameCallback } from "./bridge";
-export { createIslandStateStore, type IslandRenderState, type IslandStateStore, type PaintedAt } from "./island-state";
-export { runCompositorPass, type CompCameraLike, type GlLike, type IslandCameraLike, type PassContext, type PassStats, type PoolLike, type QuadLike, type QuadsLike, type TargetLike, } from "./compositor-pass";
-export { GLViews, type GLViewsProps, type GlFrameStats } from "./gl-root";
-export { Island, type IslandProps } from "./island";
-export { IslandContext, useIslandContext, useIslandFrame, useIslandInvalidate, useIslandLift, useIslandOpacity, type IslandContextValue, } from "./use-island-frame";
-export { RenderTargetPool, type PoolEntryInfo } from "./pool";
-export { ResourceRegistry } from "./resource-registry";
-export { CompositeMaterial } from "./composite-material";
-export { createRenderWriteTrap, type RenderWriteTrap } from "./dev-write-trap";
-export { createGLPointerRouter, type GLPointerRouter, type GLPointerRouterDeps, type IslandPointerEvent, } from "./gl-router";
-export { captureWidgetPreviews, type CapturePreviewOpts } from "./preview-capture";

package/dist/types/packages/r3f/src/island-state.d.ts

@@ -1,112 +0,0 @@
-/**
- * Module-side island render state (design-004 §3 fix #3: ZERO render→ECS
- * writes — v1 kept this as an ECS component `R3FRenderState` and wrote it
- * from inside `useFrame`, which the engine laws ban; band/generation/paint
- * bookkeeping now lives here, outside the world entirely).
- *
- * One entry per GL widget the compositor has ever touched this session.
- * Entries OUTLIVE island unmount (cull) — that is the retention decoupling:
- * a culled widget's entry keeps its `fboGeneration`/`paintedAt` so re-entry
- * composites from the retained texture (phase Warm) instead of re-waking.
- * Entries die only on entity death, world reset, or `drop()`.
- *
- * Pure state + counters; no three.js, no ECS, no timing — the GLViews frame
- * pass reads/writes it synchronously.
- */
-import type { IslandPhase } from "../../kernel/src/index";
-/** Resolution + band an island's FBO was last painted at (v1 `paintedAt`). */
-export interface PaintedAt {
-    readonly w: number;
-    readonly h: number;
-    readonly dpr: number;
-    /** The zoom BAND painted at (not live zoom) — hysteresis compares against it. */
-    readonly band: number;
-}
-export interface IslandRenderState {
-    phase: IslandPhase;
-    /** Bumped by dirt (props Tier-3, size dirt, manual invalidate). */
-    paintGeneration: number;
-    /** Generation last painted into the FBO; -1 = no valid texture (fresh or evicted). */
-    fboGeneration: number;
-    paintedAt: PaintedAt;
-    /** Live `useIslandFrame` subscriptions (animation signal while > 0). */
-    animRefs: number;
-    /** The widget type declared `animated` (repaint every visible frame). */
-    animatedDecl: boolean;
-    /**
-     * Monotonic stamp of the last repaint — the stagger's FAIRNESS key. Without
-     * it, more Hot islands than maxRepaintsPerFrame starves the same island
-     * every pass (5 Hot vs cap 4 froze the shapes card, 2026-07-12).
-     */
-    lastPaintSeq: number;
-    /**
-     * Animation time OWED to this island's `useIslandFrame` callbacks: every
-     * pass a Hot island is paint-eligible adds the pass dtMs; the paint that
-     * finally runs delivers the whole balance and zeroes it. Without this, a
-     * stagger-deferred island simply LOST the deferred passes' time — 5 Hot vs
-     * cap 4 ran every animation at 4/5 speed (2026-07-20 rate probe), violating
-     * design-004's "the cap changes cadence, never speed". Freeze semantics are
-     * preserved: frozen islands are not paint-eligible, so a stage hold still
-     * PAUSES animation rather than banking it.
-     */
-    pendingDtMs: number;
-    /**
-     * Composite-quad scale (lift-on-hold): scales the CARD on the canvas —
-     * texture, rounded alpha corners and all — instead of the scene content
-     * (which the card-sized frustum would crop into hard corners, 2026-07-12
-     * field report). ≠1 also pops render order over neighbors.
-     *
-     * This is the DRAWN value: the compositor pass eases it toward
-     * `liftTarget` (dtMs-driven spring). GL widgets have no CSS transitions, so
-     * the DOM-lift parity (2026-07-13 field report: "GL lift snaps") lives in
-     * the pass, not in userland.
-     */
-    compositeScale: number;
-    /** Where the lift is headed; `setCompositeScale` retargets from the drawn value. */
-    liftTarget: number;
-    /** Drawn value at (re)target time — the ease runs liftFrom → liftTarget. */
-    liftFrom: number;
-    /** Accumulated pass dtMs since the last retarget; ≥ liftMs ⇒ settled. */
-    liftElapsedMs: number;
-    /** Transition duration in ms; 0 = snap (the pre-ease behavior). */
-    liftMs: number;
-    /**
-     * Composite-quad opacity channel (the lift's fade twin): the DRAWN value the
-     * pass eases toward `opacityTarget` and MULTIPLIES with the widget's durable
-     * `Opacity` cell — presentation-transient (chrome-grade, e.g. the drag-lift
-     * fade) stacked over the doc-level fact, never written to ECS.
-     */
-    compositeOpacity: number;
-    /** Where the fade is headed; `setCompositeOpacity` retargets from the drawn value. */
-    opacityTarget: number;
-    /** Drawn value at (re)target time — the ease runs opacityFrom → opacityTarget. */
-    opacityFrom: number;
-    /** Accumulated pass dtMs since the last retarget; ≥ opacityMs ⇒ settled. */
-    opacityElapsedMs: number;
-    /** Transition duration in ms; 0 = snap. */
-    opacityMs: number;
-}
-/**
- * Default lift transition — the GL twin of the DOM card-lift idiom (180ms
- * springy pop; the curve itself lives in the compositor pass).
- */
-export declare const LIFT_DEFAULT_MS = 180;
-export interface IslandStateStore {
-    /** Get-or-create (Cold, unpainted). */
-    ensure(key: number): IslandRenderState;
-    get(key: number): IslandRenderState | undefined;
-    all(): IterableIterator<[number, IslandRenderState]>;
-    /** Island dirt: the next frame pass must repaint this island. */
-    bumpPaint(key: number): void;
-    markPainted(key: number, at: PaintedAt): void;
-    /** FBO released (eviction/death): the quad hides until first repaint. */
-    markEvicted(key: number): void;
-    addAnimRef(key: number): void;
-    removeAnimRef(key: number): void;
-    /** Animation signal: declared `animated` OR any live `useIslandFrame`. */
-    isAnimating(key: number): boolean;
-    setAnimatedDecl(key: number, animated: boolean): void;
-    drop(key: number): void;
-    clear(): void;
-}
-export declare function createIslandStateStore(): IslandStateStore;

package/dist/types/packages/r3f/src/island.d.ts

@@ -1,13 +0,0 @@
-import { type ReactElement } from "react";
-import { type Texture } from "three";
-import type { Entity, WidgetType, World } from "../../core/src/index";
-import type { GLBridge } from "./bridge";
-export interface IslandProps {
-    readonly bridge: GLBridge;
-    readonly world: World;
-    readonly entity: Entity;
-    readonly widget: WidgetType;
-    /** Shared IBL for this island's private scene (see GLViews.environment). */
-    readonly environment?: Texture | null;
-}
-export declare function Island({ bridge, world, entity, widget, environment }: IslandProps): ReactElement | null;

package/dist/types/packages/r3f/src/pool.d.ts

@@ -1,56 +0,0 @@
-import { WebGLRenderTarget } from "three";
-/** Snapshot row returned by {@link RenderTargetPool.entryInfos}. */
-export interface PoolEntryInfo {
-    key: number;
-    bytes: number;
-    lastUsedMs: number;
-}
-export declare class RenderTargetPool {
-    private entries;
-    private totalBytes;
-    private disposed;
-    private readonly now;
-    /**
-     * @param now Injected monotonic clock for LRU timestamps. Defaults to
-     *   `performance.now()`; tests pass a deterministic stub so `lastUsedMs`
-     *   assertions do not depend on wall-clock timing.
-     */
-    constructor(now?: () => number);
-    /**
-     * Get or create an FBO for `key` at the requested world size and effective
-     * device-pixel-ratio. Returns the existing target unchanged when its pixel
-     * dimensions already match; otherwise disposes the stale target and allocates
-     * a new one sized to the new resolution.
-     */
-    acquire(key: number, worldW: number, worldH: number, effectiveDpr: number): WebGLRenderTarget;
-    /** Look up an FBO without creating one. */
-    get(key: number): WebGLRenderTarget | null;
-    /**
-     * Refresh `lastUsedMs` without re-acquiring. The compositor calls this for
-     * every island it samples in the composition pass — without it, warm islands
-     * that never repaint would freeze their timestamp at their last paint and the
-     * LRU would treat still-visible islands as stale (design-004 §3).
-     */
-    touch(key: number): void;
-    /**
-     * Release `key`'s FBO. Returns true if something was released. Safe after
-     * dispose — returns false rather than corrupting the byte counter or
-     * double-disposing the target.
-     */
-    release(key: number): boolean;
-    /** Total GPU bytes consumed by the pool. */
-    bytesUsed(): number;
-    /** Number of FBOs currently held. */
-    size(): number;
-    /** True after `dispose()` — callers should re-create the pool instead of using it. */
-    isDisposed(): boolean;
-    /** Iterate live entries (key + target). */
-    forEach(cb: (key: number, rt: WebGLRenderTarget) => void): void;
-    /**
-     * Snapshot of every live entry's `bytes` + `lastUsedMs` — the input an
-     * eviction pass ranks by LRU.
-     */
-    entryInfos(): PoolEntryInfo[];
-    /** Dispose every FBO. After this, acquire throws and release returns false. */
-    dispose(): void;
-}

package/dist/types/packages/r3f/src/preview-capture.d.ts

@@ -1,19 +0,0 @@
-import type { Texture, WebGLRenderer } from "three";
-export interface CapturePreviewOpts {
-    /** Types to capture (default: every registered gl-surface widget). */
-    readonly types?: readonly string[];
-    /**
-     * Shared IBL. Prefer the FACTORY form: PMREM textures live on the GPU of
-     * the renderer that generated them (no CPU image), so the app's main-canvas
-     * env is EMPTY on the capture renderer (field bug 2026-07-19 — black
-     * metals). The factory receives the capture renderer and builds the env
-     * there (e.g. `(gl) => new PMREMGenerator(gl).fromScene(new RoomEnvironment(), 0.04).texture`).
-     * A plain Texture is accepted for same-renderer/CPU-backed cases.
-     */
-    readonly environment?: Texture | ((gl: WebGLRenderer) => Texture | null) | null;
-    /** Pixel density of the capture (default: fit 512px on the long side, ≤2). */
-    readonly scale?: number;
-    /** Frames advanced before the capture (animations reach a live pose). */
-    readonly settleFrames?: number;
-}
-export declare function captureWidgetPreviews(opts?: CapturePreviewOpts): Promise<string[]>;

package/dist/types/packages/r3f/src/resource-registry.d.ts

@@ -1,30 +0,0 @@
-import type { BufferGeometry, Material, Texture } from "three";
-export declare class ResourceRegistry {
-    private geometries;
-    private materials;
-    private textures;
-    private disposed;
-    acquireGeometry<T extends BufferGeometry>(key: string, factory: () => T): T;
-    releaseGeometry(key: string): void;
-    acquireMaterial<T extends Material>(key: string, factory: () => T): T;
-    releaseMaterial(key: string): void;
-    acquireTexture<T extends Texture>(key: string, factory: () => T): T;
-    releaseTexture(key: string): void;
-    /** Number of distinct shared geometries currently held. */
-    geometryCount(): number;
-    /** Number of distinct shared materials currently held. */
-    materialCount(): number;
-    /** Number of distinct shared textures currently held. */
-    textureCount(): number;
-    /**
-     * Estimated GPU bytes for shared geometry attribute buffers. Best-effort —
-     * actual footprint depends on driver alignment, but a useful relative metric
-     * for the profiler.
-     */
-    geometryBytes(): number;
-    /** Dispose every resource and clear the registry. */
-    dispose(): void;
-    /** True after `dispose()` — callers should re-create the registry instead of using it. */
-    isDisposed(): boolean;
-    private releaseFrom;
-}

package/dist/types/packages/r3f/src/self-sustain.d.ts

@@ -1,39 +0,0 @@
-/**
- * Self-sustain scheduling for the demand loop (design-004 §3 animation-rate
- * amendment, 2026-07-14).
- *
- * When the ONLY reason to run another frame is ambient animation (Hot islands
- * or a stagger backlog), the loop no longer re-invalidates at native refresh:
- * on a 120 Hz panel that was 5 always-Hot islands × 120 paints/sec ≈ 96 % GPU
- * duty at idle — the fan. Instead the next pass is scheduled `1000/maxFps` ms
- * after the last pass STARTED, so ambient animation runs at ~`maxFps` and the
- * GPU idles between frames.
- *
- * What stays at native refresh:
- *  - lift eases (`liftAnimating`) — 180 ms of interaction feedback;
- *  - every EXTERNALLY invalidated frame (camera, drag, props dirt): the
- *    bridge's `requestFrame` path is untouched, so interaction still runs at
- *    display rate and Hot islands ride along uncapped while it lasts.
- *
- * The cap is approximate: the wake-up is a timeout and the actual frame lands
- * on the next vsync after it. {@link RATE_CAP_SLACK_MS} pulls the timeout half
- * a 120 Hz vsync early so the following vsync is the intended one, not one
- * past it (naive `interval` scheduling on a 120 Hz grid yields 40 fps, not 60).
- */
-/** Timeout lead so the post-timeout vsync lands on the target boundary. */
-export declare const RATE_CAP_SLACK_MS = 4;
-export interface SelfSustainStats {
-    readonly anyHot: boolean;
-    readonly pendingPaints: number;
-    readonly liftAnimating: boolean;
-}
-/**
- * Decide how the demand loop continues after a pass.
- *
- * @param stats        The pass's self-sustain signals.
- * @param elapsedMs    ms since the pass started (schedule anchor).
- * @param maxFps       Animation rate cap; `Infinity` restores uncapped.
- * @returns `"none"` (park), `"now"` (invalidate immediately), or the timeout
- *          delay in ms before invalidating.
- */
-export declare function selfSustainPlan(stats: SelfSustainStats, elapsedMs: number, maxFps: number): "none" | "now" | number;

package/dist/types/packages/r3f/src/use-island-frame.d.ts

@@ -1,39 +0,0 @@
-import type { Entity } from "../../core/src/index";
-import type { GLBridge, IslandFrameCallback } from "./bridge";
-export interface IslandContextValue {
-    readonly bridge: GLBridge;
-    readonly entity: Entity;
-}
-/** Provided per-island by `<Island>`; null outside island content. */
-export declare const IslandContext: import("react").Context<IslandContextValue | null>;
-export declare function useIslandContext(): IslandContextValue;
-/** Per-frame tick while mounted (island goes Hot). `cb(dtMs)` on paint. */
-export declare function useIslandFrame(cb: IslandFrameCallback): void;
-/**
- * One-shot repaint scheduler for content that changes outside React's render
- * cycle (imperative subscriptions, sockets). Bumps the island's paint
- * generation + wakes the demand loop.
- */
-export declare function useIslandInvalidate(): () => void;
-/**
- * Composite-quad lift: scales the CARD on the canvas (texture + rounded alpha
- * corners together) and pops it over neighbors while ≠1. Scaling scene content
- * instead crops the corners at the card-sized frustum — the 2026-07-12
- * hard-corner field report. Resets to 1 on unmount.
- *
- * The scale EASES to each new value (default 180ms, the DOM card-lift
- * spring — GL has no CSS transitions, so the compositor runs the curve;
- * 2026-07-13 field report: "GL lift snaps while DOM lifts smooth").
- * `durationMs: 0` snaps.
- */
-export declare function useIslandLift(scale: number, durationMs?: number): void;
-/**
- * Composite-quad fade — the lift's opacity twin (e.g. the drag-lift 75 %
- * fade): eases the quad's drawn opacity to `opacity` (default 180ms; 0
- * snaps) and MULTIPLIES the widget's durable `Opacity` cell, so a transient
- * fade stacks over a doc-level opacity instead of fighting it. The DOM
- * chrome runs its own CSS `opacity … ease` transition — same duration/curve
- * family, so card body and GL content fade in lockstep. Resets to 1 on
- * unmount.
- */
-export declare function useIslandOpacity(opacity: number, durationMs?: number): void;

package/dist/types/packages/react/src/infinite-canvas.d.ts

@@ -1,140 +0,0 @@
-/**
- * `<InfiniteCanvas>` — the one-line canvas mount (design-005 §5): planes +
- * adapters + reflectors + portal root, wired in node-board's PROVEN boot order
- * (apps/nodeboard/src/app.tsx). The app supplies a constructed {@link
- * CanvasEngine} (via `createCanvasEngine`); this component owns only the DOM
- * host, the reflector registrations, the pointer/keymap adapters, the rAF loop,
- * and the viewport sync — everything that must live next to a real container.
- *
- * Boot order (registration order = reflector flush order, mirrored exactly):
- *   host → planes → reflectors[ planeTransform · ground(P0, app-injected) ·
- *   domWidgets(P1/P3) · chrome(P4) · cursor · remoteCursors(P5) ] →
- *   pointer adapter → measurement (optional) → keymap → rAF loop → viewport RO.
- *
- * The dom-widgets reflector is BOTH a reflector and the host lookup WidgetRoot
- * portals into; it is created before mount and stored in state so WidgetRoot
- * renders once the hosts exist.
- *
- * Lifecycle: this component does NOT own the engine — it never calls
- * `engine.dispose()` (the engine outlives the mount; the app owns it). Unmount
- * detaches every adapter, unregisters every reflector, stops the loop, and
- * disposes the host.
- *
- * Not handled here (by design):
- *  - GL / R3F: the `@ice/r3f` wall forbids `@ice/react` importing three, so a
- *    GL layer (GLViews) mounts APP-SIDE. Use {@link onReady} to receive the host
- *    + planes and mount it yourself (like apps/glboard).
- *  - The GROUND layer (P0: dot grid, wires, snap guides — @ice/ground, three's
- *    WebGPURenderer) rides the same wall: pass its factory through the OPAQUE
- *    {@link InfiniteCanvasProps.ground} prop (`ground={ground({...})}`); this
- *    component types it structurally and never imports the package. No factory
- *    ⇒ no ground layer (headless/test boots).
- *  - Devtools: the import wall forbids `@ice/react` importing `@ice/devtools`.
- *    Wire the panel app-side against `engine.engine` (also via {@link onReady}).
- *  - Measurement: auto-sized widgets need a `MeasureQueue` passed to BOTH
- *    `createCanvasEngine({ measureQueue })` (ingest side) and this component's
- *    `measureQueue` prop (ResizeObserver side). Absent ⇒ measurement is skipped.
- */
-import { type CanvasEngine, type Entity, type GridConfig, type MeasureQueue, type ReflectorDef, type WirePreviewBuffer, type World } from "../../core/src/index";
-import { type CanvasHost, type GLRoute, type Planes, type WidgetFocusHandle } from "../../dom/src/index";
-import { type CSSProperties, type ReactElement, type ReactNode } from "react";
-import { type KeymapEntry } from "./keymap";
-/** Handed to {@link InfiniteCanvasProps.onReady} for app-side GL/devtools wiring. */
-export interface InfiniteCanvasHandle {
-    readonly engine: CanvasEngine;
-    readonly host: CanvasHost;
-    readonly planes: Planes;
-    /**
-     * Programmatic widget focus (design-007 §2.3): `focusWidget(entity)` /
-     * `blurFocus()` for `keyboard: "exclusive"` widgets. Focus is VIEW state
-     * (design-007 §2.6) — it rides this handle, not `engine.ops` (a headless
-     * engine correctly has no focus concept).
-     */
-    readonly focus: WidgetFocusHandle;
-}
-/**
- * STRUCTURAL mirror of `@ice/ground`'s GroundLayer/GroundFactory (the
- * `WidgetDef.component`-style opaque seam: react never imports the package —
- * the wall forbids three here). `@ice/ground.ground(...)` returns a function
- * assignable to this type.
- */
-export interface GroundLayerHandle {
-    readonly reflector: ReflectorDef & {
-        available(): boolean;
-    };
-    configureGrid(cfg: Partial<GridConfig>): void;
-    dispose(): void;
-}
-export type GroundLayerFactory = (ctx: {
-    readonly host: {
-        readonly container: HTMLElement;
-        readonly contentPlane: HTMLElement;
-    };
-    readonly world: World;
-    readonly readWirePreview: () => WirePreviewBuffer;
-    /**
-     * Broad-phase rect query over the interaction stack's spatial index (the
-     * magnet grid's widget sources, design-010 §3.2). Structural mirror of
-     * `@ice/ground`'s ReadSpatial — kernel AABB/SpatialEntry shapes inlined.
-     */
-    readonly readSpatial: (bounds: {
-        readonly minX: number;
-        readonly minY: number;
-        readonly maxX: number;
-        readonly maxY: number;
-    }) => ReadonlyArray<{
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-        id: Entity;
-    }>;
-}) => GroundLayerHandle;
-export interface InfiniteCanvasProps {
-    /** A constructed engine (`createCanvasEngine(...)`); NOT disposed on unmount. */
-    readonly engine: CanvasEngine;
-    /**
-     * The ResizeObserver side of widget measurement. Pass the SAME queue given to
-     * `createCanvasEngine({ measureQueue })`. Absent ⇒ measurement skipped.
-     */
-    readonly measureQueue?: MeasureQueue;
-    /** Called once after the host/reflectors/loop are live (app-side GL/devtools). */
-    readonly onReady?: (handle: InfiniteCanvasHandle) => void;
-    /**
-     * The P0 ground layer (dot grid, wires, snap guides — one WebGPU canvas).
-     * Pass `ground(opts)` from `@ice/ground`; received opaquely (see
-     * {@link GroundLayerFactory}). Memoize in the caller — a new identity
-     * re-boots the canvas mount effect. Absent ⇒ no ground layer renders.
-     */
-    readonly ground?: GroundLayerFactory;
-    /**
-     * Dot-grid tuning (theme dot color, spacing, fades). Applied live via the
-     * ground layer's `configureGrid` — changing it never re-boots the canvas
-     * (memoize in the caller to avoid redundant same-value redraws). No-op
-     * when {@link ground} is absent.
-     */
-    readonly grid?: Partial<GridConfig>;
-    /**
-     * GL pointer routing (event-time island pick — @ice/r3f's
-     * createGLPointerRouter). Provide from the FIRST render (a stub delegating
-     * to a ref is fine — the real router usually arrives in onReady); the prop
-     * is read through a ref, so later identity changes take effect without
-     * re-attaching the adapter.
-     */
-    readonly glRoute?: GLRoute;
-    /**
-     * Keymap overrides plumbed to {@link attachKeymap} (design-007 §5 M-d — the
-     * declared alternative to capture-phase `stopPropagation` folklore; retires
-     * the widgetlab C-key hack). An entry replaces a default by its
-     * `key|mod|shift` signature; conditional behavior belongs INSIDE `run`
-     * (read engine state there — e.g. selection → comment, else the default's
-     * action). BOUND ONCE at mount, like the adapter: entries should read live
-     * state from the engine at run time, never close over render-time values.
-     */
-    readonly keymapOverrides?: readonly KeymapEntry[];
-    readonly className?: string;
-    readonly style?: CSSProperties;
-    /** Overlays inside the viewport (toolbars, HUD) — rendered under the EngineProvider. */
-    readonly children?: ReactNode;
-}
-export declare function InfiniteCanvas({ engine, measureQueue, onReady, ground, grid: gridConfig, glRoute, keymapOverrides, className, style, children, }: InfiniteCanvasProps): ReactElement;

package/dist/types/packages/react/src/preview-snapshots.d.ts

@@ -1,17 +0,0 @@
-/**
- * The GL preview snapshot store (design-005 §2 preview contract, P2 —
- * 2026-07-19). react stays three-free by LAW, so the capture pipeline lives
- * in @ice/r3f and meets `<WidgetPreview>` HERE, at a dumb data seam: a
- * module-level map of widget type → captured image, with subscription so an
- * open palette re-renders the moment a capture lands.
- *
- * `PreviewImage` accepts a canvas alongside ImageBitmap so tests (and any
- * app-side prebuilt-cache policy — the P3 seam) can inject without a GPU.
- */
-export type PreviewImage = ImageBitmap | HTMLCanvasElement;
-export declare function setPreviewSnapshot(type: string, image: PreviewImage): void;
-export declare function getPreviewSnapshot(type: string): PreviewImage | undefined;
-export declare function hasPreviewSnapshot(type: string): boolean;
-export declare function subscribePreviewSnapshots(listener: () => void): () => void;
-/** TEST-ONLY wipe (not on the barrel). */
-export declare function __resetPreviewSnapshotsForTests(): void;