@vibecook/ice 0.1.0

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

@@ -0,0 +1,44 @@
+/**
+ * Snap guide computation (Figma-style), ported verbatim from v1
+ * `ecs/spatial/snap.ts` (audited CLEAN-PORT):
+ *   Phase 1 — edge/center alignment (7 X + 7 Y candidate pairs per reference,
+ *             per-axis nearest-wins, ties within 0.01 accumulate guides)
+ *   Phase 2 — equal spacing (between-two-neighbors midpoint; extend-a-pattern),
+ *             same-perpendicular-band filter
+ *   Merge   — alignment takes priority per axis; equal spacing fills the other;
+ *             indicators recomputed post-snap at threshold × 0.5.
+ * Pure function over plain bounds. Candidate GATHERING (spatial index, tags,
+ * Active scoping) is the caller's job — design-003 §5.2/§6.
+ */
+export interface SnapGuide {
+    axis: "x" | "y";
+    /** World-space coordinate of the alignment line */
+    position: number;
+    type: "edge" | "center";
+}
+export interface EqualSpacingIndicator {
+    axis: "x" | "y";
+    /** The equal gap value (world units) */
+    gap: number;
+    /** Pairs of (from, to) marking each equal gap segment */
+    segments: {
+        from: number;
+        to: number;
+    }[];
+    /** Position on the perpendicular axis (for rendering) */
+    perpPosition: number;
+}
+export interface SnapResult {
+    /** Snap-corrected delta (world units). Apply to entity position. */
+    snapDx: number;
+    snapDy: number;
+    guides: SnapGuide[];
+    spacings: EqualSpacingIndicator[];
+}
+export interface EntityBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function computeSnapGuides(dragged: EntityBounds, references: EntityBounds[], threshold: number): SnapResult;

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

@@ -0,0 +1,16 @@
+import type { AABB } from "./shapes";
+export interface SpatialEntry<Id> extends AABB {
+    id: Id;
+}
+export declare class SpatialIndex<Id> {
+    private tree;
+    private entries;
+    upsert(id: Id, bounds: AABB): void;
+    remove(id: Id): void;
+    /** All entries intersecting the given AABB. */
+    search(bounds: AABB): SpatialEntry<Id>[];
+    /** Entries within `tolerance` of a point (z-priority is the caller's job). */
+    searchPoint(x: number, y: number, tolerance?: number): SpatialEntry<Id>[];
+    clear(): void;
+    get size(): number;
+}

package/dist/types/packages/kernel/src/zoom-bands.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hysteresis-banded zoom-resolution policy — ported from v1 `ZoomBands.ts`
+ * (RFC-002). An island FBO is allocated at `widget bounds × dpr × band(zoom)`;
+ * while zoom stays within `[band × 0.5, band × 2]` no repaint is needed.
+ * Bands are powers of 2 (each covers a 4× display range).
+ */
+export declare const ZOOM_BANDS: readonly [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16];
+/** Smallest band ≥ zoom (clamped to the ladder). */
+export declare function selectBand(zoom: number): number;
+/**
+ * True when zoom left the `[band × 0.5, band × 2]` window of the band the
+ * island was painted at. `paintedBand ≤ 0` = never painted (handled elsewhere).
+ */
+export declare function isOutOfBand(currentZoom: number, paintedBand: number): boolean;
+/** FBO pixel size for a widget at a band (v1: `bounds × dpr × band`, min 1px). */
+export declare function fboPixelSize(worldWidth: number, worldHeight: number, dpr: number, band: number): {
+    width: number;
+    height: number;
+};

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

@@ -0,0 +1,68 @@
+/**
+ * The GL bridge — the engine↔R3F seam (design-004 §3, two-level invalidation).
+ *
+ * Owns everything ENGINE-facing: the module-side island state, the island
+ * registry (scene+camera handles the frame pass iterates), per-island dirt
+ * observers, the `r3fInvalidator` reflector, `useIslandFrame` callbacks, the
+ * render write trap, and entity-death cleanup. Everything GL-facing (FBO
+ * pool, quads, the actual passes) lives in `GLViews`, whose lifetime is the
+ * Canvas/context's — the bridge outlives Canvas remounts (HMR) and carries
+ * the invalidation wiring across them.
+ *
+ * Two-level invalidation, mechanized:
+ * - COMPOSITE dirt (cheap — re-run the frame pass, sample cached textures):
+ *   camera/viewport via the reflector; per-island Position/StackZ Tier-3;
+ *   island enter/exit via register/unregister. All call `requestFrame()`.
+ * - ISLAND dirt (expensive — repaint the FBO): per-island props-group and
+ *   Size Tier-3 → `bumpPaint()` + `requestFrame()`; the animation signal
+ *   (declared `animated` / live `useIslandFrame` refs) and band crossings
+ *   are evaluated IN the frame pass (band repaints suppressed while
+ *   `Camera.gesturing`; the gesture-end camera write re-fires the reflector,
+ *   so the once-at-gesture-end repaint needs no extra machinery).
+ *
+ * Runtime-three-free (type-only imports): unit tests drive the bridge with a
+ * real world and fake scene/camera handles, no GL context.
+ */
+import type { OrthographicCamera, Scene } from "three";
+import { type Engine, type Entity } from "@ice/core";
+import { type IslandStateStore } from "./island-state";
+import { type RenderWriteTrap } from "./dev-write-trap";
+export interface IslandHandle {
+    readonly scene: Scene;
+    readonly camera: OrthographicCamera;
+}
+/** `useIslandFrame` callback: dt in ms, fired only on frames its island paints. */
+export type IslandFrameCallback = (dtMs: number) => void;
+export interface GLBridgeOpts {
+    /** Arm the zero-render→ECS-writes trap (DEV builds / traces). Default false. */
+    readonly devAssertRenderWrites?: boolean;
+}
+export interface GLBridge {
+    readonly engine: Engine;
+    readonly state: IslandStateStore;
+    readonly renderAssert: RenderWriteTrap;
+    /**
+     * Island mount (the `<Island>` component): registers the scene/camera pair,
+     * stamps `animatedDecl` from the widget type, and arms the per-island dirt
+     * observers. The returned cleanup removes handle + observers ONLY — state
+     * and any pooled FBO survive (retention is decoupled from cull; they die on
+     * entity death, reset, or eviction).
+     */
+    registerIsland(entity: Entity, handle: IslandHandle): () => void;
+    islandFor(entity: Entity): IslandHandle | undefined;
+    islands(): IterableIterator<[Entity, IslandHandle]>;
+    /** Subscribe a paint-time callback; holds an animation ref while live. */
+    addFrameCallback(entity: Entity, cb: IslandFrameCallback): () => void;
+    frameCallbacksFor(entity: Entity): readonly IslandFrameCallback[];
+    /** Composite invalidation — schedule a frame pass (coalesced). */
+    requestFrame(): void;
+    /** Island invalidation — this island must repaint (props/size/manual dirt). */
+    bumpPaint(entity: Entity): void;
+    /** Composite-quad lift scale (1 = rest). Scales the CARD on the canvas, corners intact. */
+    setCompositeScale(entity: Entity, scale: number): void;
+    /** GLViews wires R3F's demand-loop `invalidate` here (null on unmount). */
+    setInvalidate(fn: (() => void) | null): void;
+    /** Tear down reflector + observers + state (doc close / app teardown). */
+    uninstall(): void;
+}
+export declare function createGLBridge(engine: Engine, opts?: GLBridgeOpts): GLBridge;

package/dist/types/packages/r3f/src/composite-material.d.ts

@@ -0,0 +1,17 @@
+import { ShaderMaterial } from "three";
+import type { Texture } from "three";
+/**
+ * Per-island composite material. Each island quad gets its own instance so the
+ * per-quad `map` uniform is independent; Three compiles the shader once and
+ * reuses the program across instances since they share source (verify in dev via
+ * `renderer.info.programs.length === 1` for the composite shader).
+ */
+export declare class CompositeMaterial extends ShaderMaterial {
+    private readonly mapUniform;
+    private readonly opacityUniform;
+    constructor();
+    /** Bind the island's FBO texture (null clears). */
+    setMap(map: Texture | null): void;
+    /** Composite opacity. Pass-through — no clamping; callers pass valid 0..1. */
+    setOpacity(opacity: number): void;
+}

package/dist/types/packages/r3f/src/compositor-pass.d.ts

@@ -0,0 +1,83 @@
+import { type Entity, type World } from "@ice/core";
+import type { GLBridge } from "./bridge";
+export interface TargetLike {
+    /** Opaque texture handle threaded to the quad (three: `.texture`). */
+    readonly texture: unknown;
+}
+export interface PoolLike {
+    acquire(key: number, worldW: number, worldH: number, effectiveDpr: number): TargetLike;
+    get(key: number): TargetLike | null;
+    touch(key: number): void;
+    release(key: number): void;
+    bytesUsed(): number;
+    entryInfos(): readonly {
+        key: number;
+        bytes: number;
+        lastUsedMs: number;
+    }[];
+}
+export interface QuadLike {
+    setTransform(x: number, y: number, sx: number, sy: number): void;
+    setTexture(t: unknown): void;
+    setVisible(v: boolean): void;
+    setRenderOrder(n: number): void;
+}
+export interface QuadsLike {
+    ensure(key: number): QuadLike;
+    remove(key: number): void;
+    keys(): readonly number[];
+}
+export interface GlLike {
+    setRenderTarget(t: TargetLike | null): void;
+    /** Clear the CURRENT target to transparent black. */
+    clear(): void;
+    render(scene: object, camera: object): void;
+    setPixelRatio(n: number): void;
+    getPixelRatio(): number;
+}
+export interface CompCameraLike {
+    setFrustum(f: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * The ACTUAL camera object handed to `gl.render` for the composite pass —
+     * three's renderer instanceof-checks it, so this must be the real
+     * `OrthographicCamera`, NOT this adapter. (Field bug 2026-07-10: the pass
+     * rendered with the adapter itself; three threw "camera is not an instance
+     * of THREE.Camera" every frame and P2 never composited. The headless fakes
+     * couldn't catch it — both types erase to `object` and the fake render is
+     * a no-op.)
+     */
+    readonly raw: object;
+}
+export interface IslandCameraLike {
+    setFrustum(halfW: number, halfH: number): void;
+}
+export interface PassContext {
+    readonly world: World;
+    readonly bridge: GLBridge;
+    readonly pool: PoolLike;
+    readonly quads: QuadsLike;
+    readonly gl: GlLike;
+    readonly compCamera: CompCameraLike;
+    /** Adapt an island's ortho camera (three or fake) for frustum writes. */
+    readonly islandCamera: (entity: Entity) => IslandCameraLike | undefined;
+    readonly compositeScene: object;
+    readonly maxFboBytes: number;
+    readonly maxRepaintsPerFrame: number;
+    readonly dtMs: number;
+}
+export interface PassStats {
+    repainted: number;
+    /** Paint-needing islands deferred by the stagger cap — caller re-invalidates. */
+    pendingPaints: number;
+    evicted: number;
+    fboBytes: number;
+    anyHot: boolean;
+}
+export declare function runCompositorPass(ctx: PassContext): PassStats;

package/dist/types/packages/r3f/src/dev-write-trap.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The zero-render→ECS-writes DEV assertion (M7 exit criterion; design-004 §3
+ * fix #3). While a compositor frame pass runs — including island paints and
+ * `useIslandFrame` callbacks — every world mutation throws with attribution.
+ *
+ * strata 0.4.0 (petition 4 LANDED): one persistent `world.devOnWrite`
+ * registration + an armed flag. The hook is DEV-only, synchronous, and
+ * PRE-MUTATION with throws propagating to the mutator's caller — so a throw
+ * while armed is a clean veto whose stack names the offender. Fired from
+ * strata's internal chokepoints, it covers every route the old own-property
+ * mutator shadows could miss: bound/destructured method references, document
+ * transactions, sync/attach drains, undo echoes, and any mutator added
+ * upstream later. (Raw `batch.col()` column pokes remain the documented
+ * carve-out — no chokepoint exists by design.)
+ *
+ * `enabled` is the app-side production gate the 0.4.0 notes ask for: in an
+ * un-shimmed browser production bundle strata's own DEV flag can evaluate
+ * true, so registration is gated HERE (default off; demos/traces opt in).
+ */
+import type { World } from "@ice/core";
+export interface RenderWriteTrap {
+    /** Arm the trap (begin twice without end is a bug — throws). */
+    begin(): void;
+    /** Disarm; always call in `finally`. */
+    end(): void;
+    /** Unregister the hook entirely (bridge teardown). */
+    dispose(): void;
+    readonly enabled: boolean;
+}
+export declare function createRenderWriteTrap(world: World, enabled: boolean): RenderWriteTrap;

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

@@ -0,0 +1,21 @@
+import { type ReactElement } from "react";
+import { type Texture } from "three";
+import { type Engine, type WidgetMountStore } from "@ice/core";
+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;
+    /**
+     * 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;
+}
+export declare function GLViews({ engine, bridge, store, maxFboBytes, maxRepaintsPerFrame, environment, }: GLViewsProps): ReactElement;

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

@@ -0,0 +1,60 @@
+/**
+ * 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 "@ice/kernel";
+import { type Entity, type World } from "@ice/core";
+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;
+}
+export declare function createGLPointerRouter({ world, bridge, index }: GLPointerRouterDeps): GLPointerRouter;

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

@@ -0,0 +1,16 @@
+/**
+ * @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 } from "./gl-root";
+export { Island, type IslandProps } from "./island";
+export { IslandContext, useIslandContext, useIslandFrame, useIslandInvalidate, useIslandLift, 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";

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

@@ -0,0 +1,68 @@
+/**
+ * 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 "@ice/kernel";
+/** 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;
+    /**
+     * 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.
+     */
+    compositeScale: number;
+}
+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

@@ -0,0 +1,13 @@
+import { type ReactElement } from "react";
+import { type Texture } from "three";
+import type { Entity, WidgetType, World } from "@ice/core";
+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

@@ -0,0 +1,56 @@
+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/resource-registry.d.ts

@@ -0,0 +1,30 @@
+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/use-island-frame.d.ts

@@ -0,0 +1,24 @@
+import type { Entity } from "@ice/core";
+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.
+ */
+export declare function useIslandLift(scale: number): void;

package/dist/types/packages/react/src/engine-context.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `<EngineProvider>` + engine access hooks (design-005 §5; the M6 field
+ * amendment 2026-07-10 gap — grep "useCommit" in design-005).
+ *
+ * The whole React surface reaches the running canvas through ONE context
+ * carrying the {@link CanvasEngine} facade (world + engine + stack + runtime +
+ * ops + docs). Widgets never hand-roll store plumbing again: {@link useOps}
+ * gives the engine-owned write paths, {@link useCommit} (its own module) the
+ * sanctioned durable commit seam, and {@link useWorld} the read/observe escape
+ * hatch. `<InfiniteCanvas>` provides this automatically; apps that mount
+ * WidgetRoot themselves wrap it in `<EngineProvider>`.
+ */
+import { type CanvasEngine, type CanvasOps, type World } from "@ice/core";
+import { type ReactElement, type ReactNode } from "react";
+export interface EngineProviderProps {
+    readonly engine: CanvasEngine;
+    readonly children?: ReactNode;
+}
+/** Publish the canvas engine to the React subtree (WidgetRoot + userland hooks). */
+export declare function EngineProvider({ engine, children }: EngineProviderProps): ReactElement;
+/** The canvas engine for this subtree; throws with guidance outside a provider. */
+export declare function useCanvasEngine(): CanvasEngine;
+/** The engine-owned write paths (design-005 §4): setTool, deleteSelection, etc. */
+export declare function useOps(): CanvasOps;
+/**
+ * Escape hatch — the raw {@link World} for READS and Tier-3 OBSERVATION only.
+ * Mutation goes through {@link useOps}/{@link useCommit} (a gesture-claimed,
+ * one-tx-per-gesture durable write; direct world writes bypass sovereignty and
+ * the guards). DEV-warns once on first use.
+ */
+export declare function useWorld(): World;

package/dist/types/packages/react/src/hooks.d.ts

@@ -0,0 +1,40 @@
+/**
+ * React hooks over the engine's Tier-3 reactivity (design-005 §2 hooks;
+ * design-004 §2 frozen-hidden rule).
+ *
+ * Implemented directly on `world.reactive.observeValue` + `useSyncExternalStore`
+ * rather than strata's own react module: core is react-free by law, so
+ * strata/react cannot be re-exported through it — and the adapter is ~20
+ * lines. Value semantics are strata Tier-3: equality-suppressed, fired at
+ * notify(), never during the tick.
+ *
+ * FROZEN-HIDDEN: a widget inside a hidden (culled-but-kept-mounted) host must
+ * not re-render on doc edits — `useWidgetProps` reads {@link WidgetHiddenContext}
+ * (provided per-portal by WidgetRoot) and suspends its subscription while
+ * hidden, serving the last snapshot; on show it resubscribes and refreshes.
+ */
+import { type Component, type Entity, type World } from "@ice/core";
+/** Per-portal hidden flag (WidgetRoot provides it; defaults to live). */
+export declare const WidgetHiddenContext: import("react").Context<boolean>;
+/**
+ * Tier-3 component value subscription (equality-suppressed). Snapshot
+ * STABILITY is load-bearing: strata's `get()` materializes a fresh object per
+ * read (SoA columns), and `useSyncExternalStore` treats a new reference as a
+ * new snapshot — so reads go through a shallow-equality cache and only a real
+ * field change yields a new reference.
+ */
+export declare function useWorldComponent<S>(world: World, entity: Entity, component: Component<S>): S | undefined;
+/**
+ * Typed props for one conflict group of a widget (design-005 §2). Group
+ * component values come back whole; `p.json` fields are parsed. Identity is
+ * stable per underlying group value (memo on the raw reference).
+ */
+export declare function useWidgetProps<T extends Record<string, unknown>>(world: World, entity: Entity, type: string, group?: string): T | undefined;
+/**
+ * Selection membership (Tier-1 wake on Selected churn; O(1) snapshot).
+ * Frozen-hidden like every widget hook: a selection change must not re-render
+ * 256 hidden trees (review finding — design-004 §2 applies to ALL hooks).
+ */
+export declare function useSelected(world: World, entity: Entity): boolean;
+/** LOD tier (design-004 §8); "normal" until the breakpoint system stamps one. */
+export declare function useBreakpoint(world: World, entity: Entity): string;