@vibecook/ice 0.10.0 → 0.14.0

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

@@ -1,63 +0,0 @@
-/**
- * Magnet-grid collector — the pure ECS→packed-sources half of the magnet pass
- * (design-010 §4; the `*-collect.ts` convention: imports ONLY core/kernel so
- * it unit-tests under happy-dom with no GPU and no three import).
- *
- * Ported from vibe-field draft/magnet-grid `main.js` (latticeWindow,
- * packCards) with the design-010 upgrades the experiment lacked:
- *  - rbush broad-phase over the ONE spatial index instead of an all-cards
- *    walk (D2 — document size becomes irrelevant by construction);
- *  - N poles from injected sources, packed as DEGENERATE rounded boxes
- *    (half = 0, r = 0 — reduces exactly to the point-charge formula, D3);
- *  - `maxSources` prioritization (largest screen area, then nearest to the
- *    viewport center; poles pack first and are never evicted);
- *  - `fadeZoom` — the field quiets below a zoom threshold (scale 0 skips the
- *    spatial query entirely: the cheap valve is also the right look).
- */
-import { type Entity, type GridConfig, type GridMagnetConfig, type World } from "../../../core/src/index";
-import { type AABB, type SpatialEntry } from "../../../kernel/src/index";
-import type { GroundFrame } from "../pass";
-import type { Pole } from "../poles";
-/** Floats per packed source: [cx, cy, hx, hy] + [r, strength, 0, 0] (screen px). */
-export declare const MAGNET_SOURCE_FLOATS = 8;
-/** Source-buffer capacity — the scratch array and GPU buffer are sized to this. */
-export declare const MAX_MAGNET_SOURCES = 256;
-/** Per-level instance guard (vibe-field main.js:621 — a level beyond it draws nothing). */
-export declare const MAX_MAGNET_INSTANCES = 220000;
-/** The broad-phase reader over the shared spatial index (ctx seam, design-010 §3.2). */
-export type ReadSpatial = (bounds: AABB) => readonly SpatialEntry<Entity>[];
-/** Resolve the partial config block over the defaults — the ONE resolution point. */
-export declare function resolveMagnet(cfg: GridConfig): GridMagnetConfig;
-/** Closed-form fade ladder (grid.ts:72-74 re-expressed in JS for level skip). */
-export declare function fadeOpacity(cssSpacing: number, fadeIn: readonly [number, number], fadeOut: readonly [number, number]): number;
-/**
- * The field zoom valve: 1 at `zoom ≥ fadeZoom`, lerping to 0 across
- * [0.7·fadeZoom, fadeZoom]. 0 disables the valve entirely.
- */
-export declare function magnetFieldScale(zoom: number, fadeZoom: number): number;
-/** One lattice level's visible window + fade (vibe-field main.js:81-91 port). */
-export interface MagnetLevel {
-    /** Integer lattice coords of the window origin. */
-    readonly i0: number;
-    readonly j0: number;
-    readonly cols: number;
-    readonly rows: number;
-    /** Instances to draw; 0 = level skipped (faded out or over the guard). */
-    readonly count: number;
-    /** Fade-ladder opacity × level weight (CPU-baked; the shader gets one alpha). */
-    readonly alpha: number;
-    /**
-     * Coincidence skip (design-010 §5.4): when the NEXT level up is visible and
-     * its spacing is an integer multiple m of this one, sites whose absolute
-     * lattice index is ≡ 0 (mod m) on both axes drop out — replicating the
-     * classic shader's max-composite look. 0 = no skip.
-     */
-    readonly skipModulo: number;
-}
-export declare function collectMagnetLevels(frame: GroundFrame, cfg: GridConfig): MagnetLevel[];
-/**
- * Pack field sources into `out` (stride {@link MAGNET_SOURCE_FLOATS}, screen
- * CSS px). Returns the packed count. `fieldScale` multiplies every strength
- * (the zoom valve); 0 short-circuits to an empty buffer — no spatial query.
- */
-export declare function collectMagnetSources(world: World, frame: GroundFrame, magnet: GridMagnetConfig, fieldScale: number, poles: readonly Pole[], readSpatial: ReadSpatial | undefined, out: Float32Array): number;

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

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

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

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

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

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

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

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

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

@@ -1,47 +0,0 @@
-/**
- * Magnet pole sources (design-010 §3.3, decision D5): the grid pass is
- * CURSOR-AGNOSTIC — point field sources enter through this injected protocol,
- * never through pass-known vocabulary. No source wired ⇒ no subscription, no
- * reads, widget-only field. The canned helpers below are where any cursor
- * dependency lives; the pass imports NEITHER — apps compose what fits
- * (vibe-field wraps its own `Cur` halo the same way, in its own repo).
- */
-import { type World } from "../../core/src/index";
-/**
- * One point field source. Packed as a degenerate rounded-box SDF (half = 0,
- * r = 0), which reduces exactly to the point-charge formula (design-010 D3).
- * `space` defaults to "world"; "screen" is CSS px — zero-conversion for
- * screen-space cursors (field evaluation is screen-space anyway).
- */
-export interface Pole {
-    readonly x: number;
-    readonly y: number;
-    /** Relative field strength; ≤ 0 poles are skipped at pack time. */
-    readonly strength: number;
-    readonly space?: "world" | "screen";
-}
-export interface PoleSource {
-    /** Called during collect — read-only world access (GroundPass.collect rules). */
-    read(world: World): readonly Pole[];
-    /**
-     * Called during arm — `wake` marks the grid pass dirty (the pass gates it on
-     * `magnet.enabled`, so idle scenes stay at zero frames). Returns unsubscriber.
-     */
-    subscribe(world: World, wake: () => void): () => void;
-}
-/**
- * Poles from the local pointer entity (`LocalPointer` + `PointerWorld`) — the
- * raw-cursor wiring for apps without their own cursor visual. World-space; one
- * pole per local pointer (multi-touch yields one per finger while pressed).
- */
-export declare function localPointerPoles(opts?: {
-    readonly strength?: number;
-}): PoleSource;
-/**
- * Poles from cursor-visual entities (`Position` + `CursorVisual`) — presence
- * apps: remote collaborators' pooled cursors (core `remote-cursors.ts`) drive
- * the field. This helper is where the CursorVisual dependency lives (D5).
- */
-export declare function cursorVisualPoles(opts?: {
-    readonly strength?: number;
-}): PoleSource;

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

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

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

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

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

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

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

@@ -1,23 +0,0 @@
-/**
- * FBO-pool eviction policy — ported from v1 `eviction.ts` (pure part of the
- * pool). Priority: Cold(0) < Warm(1) < Dormant(2); LRU within a phase;
- * Hot/Waking are never evicted even under an impossible budget.
- */
-export type IslandPhase = "Hot" | "Warm" | "Waking" | "Cold" | "Dormant";
-export interface EvictionCandidate<Id> {
-    id: Id;
-    phase: IslandPhase;
-    bytes: number;
-    lastUsedMs: number;
-}
-/**
- * The island phase truth table (design-004 §3; v1 `computePhase` verbatim —
- * RFC-002 pinned it with tests). `active` is the nested-canvas membership
- * signal (always true until M8); `hasFbo` splits Warm (retained texture,
- * composite-ready) from Waking (must paint before compositing) — after an
- * eviction a re-entering island comes back as Waking, after a plain cull
- * round-trip it comes back Warm from the retained texture.
- */
-export declare function computeIslandPhase(active: boolean, visible: boolean, animating: boolean, hasFbo: boolean): IslandPhase;
-/** Ordered ids to release so total bytes ≤ budget. Pure. */
-export declare function selectEvictions<Id>(candidates: EvictionCandidate<Id>[], totalBytes: number, maxBytes: number): Id[];

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

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,129 +0,0 @@
-/**
- * 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`/`r3fAdvance` reflectors, `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 frame 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 Tier-3; the frame
- *   ChildOf reorder wake (petition 8 — quad renderOrder is sibling order);
- *   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).
- *
- * REFLECT-PHASE ADVANCE (design-004 §3 amendment, 2026-07-20 — the pan-lag
- * fix): the composite render is driven FROM the engine's reflect phase, not
- * from R3F's demand loop. `requestFrame()` only latches `wantsFrame`; the
- * `r3fAdvance` reflector (`always: true` — registered right after the
- * observed invalidator so same-flush dirt is consumed) calls the wired
- * `renderNow` (R3F `advance`) synchronously. DOM plane transforms and the GL
- * composite therefore commit in the SAME task and present in the same frame.
- * The prior wiring (`invalidate()` → R3F's own rAF) could only arm R3F for
- * the NEXT frame, and rAF registration order between the two loops is sticky
- * luck — field-measured on 2026-07-20: R3F rendering the PREVIOUS frame's
- * camera while the DOM plane showed the current one, a permanent one-frame
- * smear under fast pans. Ambient animation rides the same seam: the pass
- * reports its self-sustain plan via `schedulePass`, and the due-time check
- * replaces the old wake-up timer (the engine loop runs every frame anyway).
- * The Canvas must mount `frameloop="never"` — a self-scheduling loop would
- * re-render out of phase again.
- *
- * 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, type SiblingOrderIndex } from "../../core/src/index";
-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;
-    /**
-     * Injected monotonic clock for the ambient-animation due-time (tests pass a
-     * stub — the pool's injected-`now` precedent). Default `performance.now`.
-     */
-    readonly now?: () => number;
-}
-export interface GLBridge {
-    readonly engine: Engine;
-    readonly state: IslandStateStore;
-    readonly renderAssert: RenderWriteTrap;
-    /**
-     * The frame ordinal cache (petition 8): the compositor pass reads quad
-     * renderOrder from it, and its `ordinals()` read resets the staleness the
-     * bridge's reorder wake filters on — bridge and pass MUST share it.
-     */
-    readonly order: SiblingOrderIndex;
-    /**
-     * 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 — latch a frame pass (coalesced). Consumed by the
-     * `r3fAdvance` reflector on the NEXT engine flush: dirt raised during a
-     * step (observers, the invalidator reflector) renders the SAME frame; dirt
-     * raised outside a step (React effects) renders on the next tick.
-     */
-    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. Sets the TARGET: the compositor pass eases the drawn
-     * value there over `durationMs` (default 180 — the DOM card-lift spring;
-     * 0 snaps). Mid-flight retargets restart from the current drawn value.
-     */
-    setCompositeScale(entity: Entity, scale: number, durationMs?: number): void;
-    /**
-     * Composite-quad opacity (1 = rest) — the lift's fade twin. MULTIPLIES the
-     * widget's durable `Opacity` cell in the pass (presentation-transient over
-     * the doc fact). Sets the TARGET: the pass eases the drawn value there over
-     * `durationMs` (default 180; 0 snaps); mid-flight retargets restart from the
-     * current drawn value.
-     */
-    setCompositeOpacity(entity: Entity, opacity: number, durationMs?: number): void;
-    /**
-     * GLViews wires R3F's `advance` here (null on unmount). Called ONLY by the
-     * `r3fAdvance` reflector, synchronously inside the engine's reflect phase —
-     * the same task the DOM reflectors write in, so both surfaces present the
-     * same camera. While unwired, latched dirt survives and renders on the
-     * first flush after (re)mount.
-     */
-    setRenderNow(fn: ((nowMs: number) => void) | null): void;
-    /**
-     * The pass reports how the frame loop continues (`selfSustainPlan`):
-     * `"now"` latches an immediate next frame (lift eases, stagger backlogs —
-     * native refresh); a number arms the ambient-animation due-time (the
-     * `maxAnimationFps` cap — replaces the old wake-up timer); `"none"` parks.
-     * Each pass re-reports, so the due-time is always the LAST pass's plan.
-     */
-    schedulePass(plan: "none" | "now" | number): 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

@@ -1,26 +0,0 @@
-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;
-    private readonly draggedRectUniform;
-    private readonly isDraggedUniform;
-    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;
-    /**
-     * Drag clip, composite-space min/max (v1's uDraggedRect re-cut from screen
-     * space). (0,0,0,0) = inactive. Mutates the vec4 in place — no allocation.
-     */
-    setDraggedRect(minX: number, minY: number, maxX: number, maxY: number): void;
-    /** True on the dragged card's own quad — exempt from the clip. */
-    setIsDragged(isDragged: boolean): void;
-}

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

@@ -1,105 +0,0 @@
-import { type Entity, type World } from "../../core/src/index";
-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;
-    /**
-     * Composite opacity, 0..1 (design-004 §3: the neutral composite's whole
-     * per-widget fact) — the pass passes `Opacity` cell × eased fade channel.
-     */
-    setOpacity(o: number): void;
-    /**
-     * Drag clip (v1 RFC-003, composite-space): non-exempt quads discard
-     * fragments inside the rect so a dragged card's P1 DOM chrome shows
-     * through. (0,0,0,0, false) = inactive.
-     */
-    setDragClip(minX: number, minY: number, maxX: number, maxY: number, exempt: boolean): 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;
-    /**
-     * Idle ceiling on island paint resolution (design-004 §3 amendment,
-     * 2026-07-14): new paints allocate at `min(pixelRatio, maxPaintDpr) × band`.
-     * On a dpr-2 display the composite's bilinear upscale from a 1.5× texture is
-     * visually indistinguishable (A/B knot crops) while Hot repaint cost drops
-     * ~22 %. Composes with the gesture drop (pixelRatio is already 1 while
-     * gesturing) and with zoom bands. `Infinity` = uncapped.
-     */
-    readonly maxPaintDpr: 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;
-    /** A composite ease (lift scale or fade) is mid-flight — caller re-invalidates (composite-only frames). */
-    liftAnimating: boolean;
-}
-export declare function runCompositorPass(ctx: PassContext): PassStats;

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

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