@vibecook/ice 0.1.0

package/dist/r3f.js

@@ -0,0 +1,1101 @@
+import {
+  Camera,
+  Grab,
+  Position,
+  PrefabId,
+  RUNTIME_BUDGETS,
+  Size,
+  StackZ,
+  Viewport,
+  Visible,
+  pickTopAt,
+  widgets
+} from "./chunk-5S7GSXJG.js";
+import {
+  compositeCameraFrustum,
+  computeIslandPhase,
+  fboPixelSize,
+  isOutOfBand,
+  screenToWorld,
+  selectBand,
+  selectEvictions,
+  worldRectToComposite,
+  worldToIsland
+} from "./chunk-BCJ47SX7.js";
+
+// ../r3f/src/island-state.ts
+var FRESH_PAINTED_AT = { w: 0, h: 0, dpr: 1, band: 0 };
+function createIslandStateStore() {
+  const entries = /* @__PURE__ */ new Map();
+  let paintSeq = 0;
+  const ensure = (key) => {
+    let s = entries.get(key);
+    if (s === void 0) {
+      s = {
+        phase: "Cold",
+        paintGeneration: 0,
+        fboGeneration: -1,
+        paintedAt: FRESH_PAINTED_AT,
+        animRefs: 0,
+        animatedDecl: false,
+        lastPaintSeq: 0,
+        compositeScale: 1
+      };
+      entries.set(key, s);
+    }
+    return s;
+  };
+  return {
+    ensure,
+    get: (key) => entries.get(key),
+    all: () => entries.entries(),
+    bumpPaint(key) {
+      ensure(key).paintGeneration += 1;
+    },
+    markPainted(key, at) {
+      const s = ensure(key);
+      s.fboGeneration = s.paintGeneration;
+      s.paintedAt = at;
+      s.lastPaintSeq = ++paintSeq;
+    },
+    markEvicted(key) {
+      const s = entries.get(key);
+      if (s !== void 0) s.fboGeneration = -1;
+    },
+    addAnimRef(key) {
+      ensure(key).animRefs += 1;
+    },
+    removeAnimRef(key) {
+      const s = entries.get(key);
+      if (s !== void 0 && s.animRefs > 0) s.animRefs -= 1;
+    },
+    isAnimating(key) {
+      const s = entries.get(key);
+      return s !== void 0 && (s.animatedDecl || s.animRefs > 0);
+    },
+    setAnimatedDecl(key, animated) {
+      ensure(key).animatedDecl = animated;
+    },
+    drop(key) {
+      entries.delete(key);
+    },
+    clear() {
+      entries.clear();
+    }
+  };
+}
+
+// ../r3f/src/dev-write-trap.ts
+function createRenderWriteTrap(world, enabled) {
+  let armed = false;
+  let unregister = null;
+  if (enabled) {
+    unregister = world.devOnWrite((kind) => {
+      if (!armed) return;
+      throw new Error(
+        `ice: world mutation (${kind}) during the GL render pass \u2014 the render path never writes ECS (design-004 \xA73). Move the write to a system, an input fact, or an app op OUTSIDE useIslandFrame/render.`
+      );
+    });
+  }
+  return {
+    enabled,
+    begin() {
+      if (!enabled) return;
+      if (armed) throw new Error("ice: render write trap begin() while already armed.");
+      armed = true;
+    },
+    end() {
+      armed = false;
+    },
+    dispose() {
+      armed = false;
+      unregister?.();
+      unregister = null;
+    }
+  };
+}
+
+// ../r3f/src/bridge.ts
+function createGLBridge(engine, opts = {}) {
+  const world = engine.world;
+  const state = createIslandStateStore();
+  const islands = /* @__PURE__ */ new Map();
+  const frameCbs = /* @__PURE__ */ new Map();
+  const renderAssert = createRenderWriteTrap(world, opts.devAssertRenderWrites === true);
+  let invalidate = null;
+  let pending = false;
+  const requestFrame = () => {
+    if (invalidate !== null) invalidate();
+    else pending = true;
+  };
+  const removeReflector = engine.registerReflector({
+    name: "r3fInvalidator",
+    observe: { resources: [Camera, Viewport] },
+    flush: () => requestFrame()
+  });
+  const removeWorldObserver = world.observe({
+    onDestroy: (e) => {
+      if (state.get(e) !== void 0) {
+        state.drop(e);
+        frameCbs.delete(e);
+        requestFrame();
+      }
+    },
+    onReset: () => {
+      state.clear();
+      frameCbs.clear();
+      requestFrame();
+    }
+  });
+  return {
+    engine,
+    state,
+    renderAssert,
+    registerIsland(entity, handle) {
+      islands.set(entity, handle);
+      const s = state.ensure(entity);
+      const type = world.get(entity, PrefabId)?.id;
+      const widget = typeof type === "string" ? widgets.get(type) : void 0;
+      state.setAnimatedDecl(entity, widget?.animated === true);
+      const unsubs = [
+        // island dirt — content resolution/props changed, FBO stale:
+        world.reactive.observeValue(entity, Size, () => {
+          state.bumpPaint(entity);
+          requestFrame();
+        }),
+        // composite dirt — quad transform/order changed, texture still good:
+        world.reactive.observeValue(entity, Position, () => requestFrame()),
+        world.reactive.observeValue(entity, StackZ, () => requestFrame())
+      ];
+      for (const group of widget?.groups ?? []) {
+        unsubs.push(
+          world.reactive.observeValue(entity, group.component, () => {
+            state.bumpPaint(entity);
+            requestFrame();
+          })
+        );
+      }
+      if (s.fboGeneration < 0) state.bumpPaint(entity);
+      requestFrame();
+      return () => {
+        for (const u of unsubs) u();
+        islands.delete(entity);
+        requestFrame();
+      };
+    },
+    islandFor: (entity) => islands.get(entity),
+    islands: () => islands.entries(),
+    addFrameCallback(entity, cb) {
+      let set = frameCbs.get(entity);
+      if (set === void 0) {
+        set = /* @__PURE__ */ new Set();
+        frameCbs.set(entity, set);
+      }
+      set.add(cb);
+      state.addAnimRef(entity);
+      requestFrame();
+      return () => {
+        set.delete(cb);
+        state.removeAnimRef(entity);
+      };
+    },
+    frameCallbacksFor(entity) {
+      const set = frameCbs.get(entity);
+      return set === void 0 ? [] : [...set];
+    },
+    requestFrame,
+    bumpPaint(entity) {
+      state.bumpPaint(entity);
+      requestFrame();
+    },
+    setCompositeScale(entity, scale) {
+      const s = state.ensure(entity);
+      if (s.compositeScale === scale) return;
+      s.compositeScale = scale;
+      requestFrame();
+    },
+    setInvalidate(fn) {
+      invalidate = fn;
+      if (fn !== null && pending) {
+        pending = false;
+        fn();
+      }
+    },
+    uninstall() {
+      removeReflector();
+      removeWorldObserver();
+      renderAssert.dispose();
+      islands.clear();
+      frameCbs.clear();
+      state.clear();
+      invalidate = null;
+    }
+  };
+}
+
+// ../r3f/src/compositor-pass.ts
+var GRABBED_RENDER_ORDER = 1e9;
+function runCompositorPass(ctx) {
+  const { world, bridge, pool, quads, gl } = ctx;
+  const stats = { repainted: 0, pendingPaints: 0, evicted: 0, fboBytes: 0, anyHot: false };
+  const cam = world.getResource(Camera);
+  const vp = world.getResource(Viewport);
+  if (cam === void 0 || vp === void 0 || vp.w === 0) return stats;
+  ctx.compCamera.setFrustum(compositeCameraFrustum(cam, vp.w, vp.h));
+  const idleDpr = vp.dpr > 0 ? vp.dpr : 1;
+  const targetDpr = cam.gesturing ? Math.min(idleDpr, 1) : idleDpr;
+  if (gl.getPixelRatio() !== targetDpr) gl.setPixelRatio(targetDpr);
+  const phaseOf = (e) => {
+    const alive = world.isAlive(e);
+    const visible = alive && world.hasTag(e, Visible) && bridge.islandFor(e) !== void 0;
+    const s = bridge.state.get(e);
+    const hasFbo = s !== void 0 && s.fboGeneration >= 0 && pool.get(e) !== null;
+    return computeIslandPhase(true, visible, bridge.state.isAnimating(e), hasFbo);
+  };
+  for (const [e, s] of bridge.state.all()) {
+    s.phase = phaseOf(e);
+    if (s.phase === "Hot") stats.anyHot = true;
+  }
+  const band = selectBand(cam.zoom);
+  const effectiveDpr = gl.getPixelRatio() * band;
+  const toPaint = [];
+  for (const [e, s] of bridge.state.all()) {
+    if (bridge.islandFor(e) === void 0) continue;
+    const wantsPhase = s.phase === "Hot" || s.phase === "Waking";
+    const genDirty = s.paintGeneration > s.fboGeneration;
+    const bandStale = !cam.gesturing && s.fboGeneration >= 0 && isOutOfBand(cam.zoom, s.paintedAt.band);
+    if (wantsPhase || genDirty || bandStale) toPaint.push(e);
+  }
+  toPaint.sort((a, b) => {
+    const sa = bridge.state.get(a);
+    const sb = bridge.state.get(b);
+    const coldA = sa !== void 0 && sa.fboGeneration < 0 ? 0 : 1;
+    const coldB = sb !== void 0 && sb.fboGeneration < 0 ? 0 : 1;
+    if (coldA !== coldB) return coldA - coldB;
+    return (sa?.lastPaintSeq ?? 0) - (sb?.lastPaintSeq ?? 0);
+  });
+  const cap = Math.max(1, ctx.maxRepaintsPerFrame);
+  for (const e of toPaint) {
+    if (stats.repainted >= cap) {
+      stats.pendingPaints = toPaint.length - stats.repainted;
+      break;
+    }
+    const handle = bridge.islandFor(e);
+    const s = bridge.state.get(e);
+    const size = world.isAlive(e) ? world.get(e, Size) : void 0;
+    if (handle === void 0 || s === void 0 || size === void 0 || size.w <= 0 || size.h <= 0) continue;
+    if (s.phase === "Hot") {
+      for (const cb of bridge.frameCallbacksFor(e)) cb(ctx.dtMs);
+    }
+    ctx.islandCamera(e)?.setFrustum(size.w / 2, size.h / 2);
+    const fbo = pool.acquire(e, size.w, size.h, effectiveDpr);
+    gl.setRenderTarget(fbo);
+    try {
+      gl.clear();
+      gl.render(handle.scene, handle.camera);
+    } finally {
+      gl.setRenderTarget(null);
+    }
+    const px = fboPixelSize(size.w, size.h, effectiveDpr, 1);
+    bridge.state.markPainted(e, { w: px.width, h: px.height, dpr: effectiveDpr, band });
+    stats.repainted += 1;
+  }
+  if (pool.bytesUsed() > ctx.maxFboBytes) {
+    const candidates = [];
+    for (const info of pool.entryInfos()) {
+      const s = bridge.state.get(info.key);
+      const phase = s === void 0 ? "Dormant" : phaseOf(info.key);
+      if (s !== void 0) s.phase = phase;
+      candidates.push({
+        id: info.key,
+        phase,
+        bytes: info.bytes,
+        lastUsedMs: info.lastUsedMs
+      });
+    }
+    for (const key of selectEvictions(candidates, pool.bytesUsed(), ctx.maxFboBytes)) {
+      if (bridge.state.get(key)?.phase === "Dormant") {
+        console.debug(`[ice/r3f] evicting Dormant island ${key} \u2014 consider raising the FBO budget`);
+      }
+      pool.release(key);
+      bridge.state.markEvicted(key);
+      stats.evicted += 1;
+    }
+  }
+  const liveKeys = /* @__PURE__ */ new Set();
+  for (const [e] of bridge.state.all()) liveKeys.add(e);
+  for (const info of pool.entryInfos()) {
+    if (!liveKeys.has(info.key)) pool.release(info.key);
+  }
+  for (const key of quads.keys()) {
+    if (!liveKeys.has(key)) quads.remove(key);
+  }
+  for (const [e, s] of bridge.state.all()) {
+    const quad = quads.ensure(e);
+    const alive = world.isAlive(e);
+    const fbo = pool.get(e);
+    const pos = alive ? world.get(e, Position) : void 0;
+    const size = alive ? world.get(e, Size) : void 0;
+    if (fbo === null || s.fboGeneration < 0 || pos === void 0 || size === void 0) {
+      quad.setVisible(false);
+      continue;
+    }
+    const q = worldRectToComposite({ x: pos.x, y: pos.y, width: size.w, height: size.h });
+    const lift = s.compositeScale;
+    quad.setTransform(q.x, q.y, q.sx * lift, q.sy * lift);
+    quad.setTexture(fbo.texture);
+    const grabbed = world.get(e, Grab) !== void 0;
+    quad.setRenderOrder(grabbed || lift !== 1 ? GRABBED_RENDER_ORDER : world.get(e, StackZ)?.z ?? 0);
+    quad.setVisible(true);
+    pool.touch(e);
+  }
+  gl.setRenderTarget(null);
+  gl.clear();
+  gl.render(ctx.compositeScene, ctx.compCamera.raw);
+  stats.fboBytes = pool.bytesUsed();
+  return stats;
+}
+
+// ../r3f/src/gl-root.tsx
+import { useFrame, useThree } from "@react-three/fiber";
+import {
+  createElement as createElement2,
+  useEffect as useEffect3,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useSyncExternalStore
+} from "react";
+import { Mesh, OrthographicCamera as OrthographicCamera2, PlaneGeometry } from "three";
+
+// ../r3f/src/composite-material.ts
+import { ShaderMaterial } from "three";
+var VERTEX_SHADER = (
+  /* glsl */
+  `
+varying vec2 vUv;
+void main() {
+  vUv = uv;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}
+`
+);
+var FRAGMENT_SHADER = (
+  /* glsl */
+  `
+uniform sampler2D map;
+uniform float uOpacity;
+varying vec2 vUv;
+
+void main() {
+  vec4 c = texture2D(map, vUv);
+  if (c.a < 0.001) discard;
+  c.a *= uOpacity;
+  gl_FragColor = c;
+  #include <colorspace_fragment>
+}
+`
+);
+var CompositeMaterial = class extends ShaderMaterial {
+  // Direct handles onto our two uniform cells. ShaderMaterial types `uniforms`
+  // as an index signature, so `this.uniforms.map` reads as possibly-undefined
+  // under strict indexing; holding the cells we created sidesteps that and keeps
+  // the setters allocation-free.
+  mapUniform;
+  opacityUniform;
+  constructor() {
+    const uniforms = {
+      map: { value: null },
+      uOpacity: { value: 1 }
+    };
+    super({
+      vertexShader: VERTEX_SHADER,
+      fragmentShader: FRAGMENT_SHADER,
+      uniforms,
+      transparent: true,
+      depthWrite: false,
+      // Explicit: this pass must never tone-map (the FBO is already display-
+      // ready). v1 left toneMapped at the ShaderMaterial default and relied on
+      // the absent tonemapping chunk alone (CompositionMaterial.ts:140-142); we
+      // set it false so the no-tone-map contract holds even if the shader ever
+      // gains chunks. Behaviour is identical for the current shader.
+      toneMapped: false
+    });
+    this.mapUniform = uniforms.map;
+    this.opacityUniform = uniforms.uOpacity;
+  }
+  /** Bind the island's FBO texture (null clears). */
+  setMap(map) {
+    this.mapUniform.value = map;
+  }
+  /** Composite opacity. Pass-through — no clamping; callers pass valid 0..1. */
+  setOpacity(opacity) {
+    this.opacityUniform.value = opacity;
+  }
+  // dispose() is inherited from ShaderMaterial — it fires the dispose event that
+  // frees the compiled program; no override needed.
+};
+
+// ../r3f/src/island.tsx
+import { createPortal } from "@react-three/fiber";
+import { createElement, useEffect as useEffect2, useMemo } from "react";
+import { OrthographicCamera, Scene } from "three";
+
+// ../r3f/src/use-island-frame.ts
+import { createContext, useCallback, useContext, useEffect, useRef } from "react";
+var IslandContext = createContext(null);
+function useIslandContext() {
+  const ctx = useContext(IslandContext);
+  if (ctx === null) {
+    throw new Error("ice: useIslandFrame/useIslandInvalidate must run inside a GL widget's island.");
+  }
+  return ctx;
+}
+function useIslandFrame(cb) {
+  const { bridge, entity } = useIslandContext();
+  const ref = useRef(cb);
+  ref.current = cb;
+  useEffect(() => bridge.addFrameCallback(entity, (dt) => ref.current(dt)), [bridge, entity]);
+}
+function useIslandInvalidate() {
+  const { bridge, entity } = useIslandContext();
+  return useCallback(() => bridge.bumpPaint(entity), [bridge, entity]);
+}
+function useIslandLift(scale) {
+  const { bridge, entity } = useIslandContext();
+  useEffect(() => {
+    bridge.setCompositeScale(entity, scale);
+  }, [bridge, entity, scale]);
+  useEffect(() => () => bridge.setCompositeScale(entity, 1), [bridge, entity]);
+}
+
+// ../r3f/src/island.tsx
+function Island({ bridge, world, entity, widget, environment }) {
+  const scene = useMemo(() => new Scene(), []);
+  const camera = useMemo(() => {
+    const cam = new OrthographicCamera(-1, 1, 1, -1, 0.1, 2e3);
+    cam.position.set(0, 0, 500);
+    cam.lookAt(0, 0, 0);
+    return cam;
+  }, []);
+  useEffect2(
+    () => bridge.registerIsland(entity, { scene, camera }),
+    [bridge, entity, scene, camera]
+  );
+  useEffect2(() => {
+    scene.environment = environment ?? null;
+    bridge.bumpPaint(entity);
+  }, [environment, scene, bridge, entity]);
+  const View = widget.component;
+  if (View == null) return null;
+  return createPortal(
+    createElement(
+      IslandContext.Provider,
+      { value: { bridge, entity } },
+      createElement(View, { entity, world })
+    ),
+    scene
+  );
+}
+
+// ../r3f/src/pool.ts
+import { SRGBColorSpace, WebGLRenderTarget } from "three";
+var COLOR_BYTES_PER_PIXEL = 4;
+var SAMPLES = 4;
+function targetBytes(pixelWidth, pixelHeight) {
+  return pixelWidth * pixelHeight * COLOR_BYTES_PER_PIXEL * (SAMPLES > 1 ? 2 : 1);
+}
+var RenderTargetPool = class {
+  entries = /* @__PURE__ */ new Map();
+  totalBytes = 0;
+  disposed = false;
+  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 = () => performance.now()) {
+    this.now = now;
+  }
+  /**
+   * 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, worldW, worldH, effectiveDpr) {
+    if (this.disposed) {
+      throw new Error("RenderTargetPool: cannot acquire after dispose");
+    }
+    const pixelWidth = Math.max(1, Math.round(worldW * effectiveDpr));
+    const pixelHeight = Math.max(1, Math.round(worldH * effectiveDpr));
+    const nowMs = this.now();
+    const existing = this.entries.get(key);
+    if (existing && existing.pixelWidth === pixelWidth && existing.pixelHeight === pixelHeight) {
+      existing.lastUsedMs = nowMs;
+      return existing.rt;
+    }
+    if (existing) {
+      existing.rt.dispose();
+      this.totalBytes -= existing.bytes;
+    }
+    const rt = new WebGLRenderTarget(pixelWidth, pixelHeight, { samples: SAMPLES });
+    rt.texture.colorSpace = SRGBColorSpace;
+    const bytes = targetBytes(pixelWidth, pixelHeight);
+    this.entries.set(key, { rt, pixelWidth, pixelHeight, effectiveDpr, bytes, lastUsedMs: nowMs });
+    this.totalBytes += bytes;
+    return rt;
+  }
+  /** Look up an FBO without creating one. */
+  get(key) {
+    return this.entries.get(key)?.rt ?? 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) {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.lastUsedMs = this.now();
+  }
+  /**
+   * 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) {
+    if (this.disposed) return false;
+    const entry = this.entries.get(key);
+    if (!entry) return false;
+    entry.rt.dispose();
+    this.totalBytes = Math.max(0, this.totalBytes - entry.bytes);
+    this.entries.delete(key);
+    return true;
+  }
+  /** Total GPU bytes consumed by the pool. */
+  bytesUsed() {
+    return this.totalBytes;
+  }
+  /** Number of FBOs currently held. */
+  size() {
+    return this.entries.size;
+  }
+  /** True after `dispose()` — callers should re-create the pool instead of using it. */
+  isDisposed() {
+    return this.disposed;
+  }
+  /** Iterate live entries (key + target). */
+  forEach(cb) {
+    for (const [key, entry] of this.entries) cb(key, entry.rt);
+  }
+  /**
+   * Snapshot of every live entry's `bytes` + `lastUsedMs` — the input an
+   * eviction pass ranks by LRU.
+   */
+  entryInfos() {
+    const out = [];
+    for (const [key, entry] of this.entries) {
+      out.push({ key, bytes: entry.bytes, lastUsedMs: entry.lastUsedMs });
+    }
+    return out;
+  }
+  /** Dispose every FBO. After this, acquire throws and release returns false. */
+  dispose() {
+    if (this.disposed) return;
+    for (const entry of this.entries.values()) entry.rt.dispose();
+    this.entries.clear();
+    this.totalBytes = 0;
+    this.disposed = true;
+  }
+};
+
+// ../r3f/src/gl-root.tsx
+function GLViews({
+  engine,
+  bridge,
+  store,
+  maxFboBytes = RUNTIME_BUDGETS.fboBytes,
+  maxRepaintsPerFrame = 4,
+  environment
+}) {
+  const world = engine.world;
+  const gl = useThree((s) => s.gl);
+  const scene = useThree((s) => s.scene);
+  const set = useThree((s) => s.set);
+  const invalidate = useThree((s) => s.invalidate);
+  const poolRef = useRef2(null);
+  if (poolRef.current === null || poolRef.current.isDisposed()) {
+    poolRef.current = new RenderTargetPool();
+  }
+  const pool = poolRef.current;
+  const quadGeometry = useMemo2(() => new PlaneGeometry(1, 1), []);
+  const compCamera = useMemo2(() => new OrthographicCamera2(0, 1, 0, -1, 0.1, 1e4), []);
+  useEffect3(() => {
+    set({ camera: compCamera });
+  }, [set, compCamera]);
+  const quadsRef = useRef2(/* @__PURE__ */ new Map());
+  const quads = useMemo2(
+    () => ({
+      ensure(key) {
+        let mesh = quadsRef.current.get(key);
+        if (mesh === void 0) {
+          mesh = new Mesh(quadGeometry, new CompositeMaterial());
+          mesh.frustumCulled = false;
+          mesh.visible = false;
+          scene.add(mesh);
+          quadsRef.current.set(key, mesh);
+        }
+        const m = mesh;
+        return {
+          setTransform: (x, y, sx, sy) => {
+            m.position.set(x, y, 0);
+            m.scale.set(sx, sy, 1);
+          },
+          setTexture: (t) => m.material.setMap(t),
+          setVisible: (v) => {
+            m.visible = v;
+          },
+          setRenderOrder: (n) => {
+            m.renderOrder = n;
+          }
+        };
+      },
+      remove(key) {
+        const mesh = quadsRef.current.get(key);
+        if (mesh !== void 0) {
+          scene.remove(mesh);
+          mesh.material.dispose();
+          quadsRef.current.delete(key);
+        }
+      },
+      keys: () => [...quadsRef.current.keys()]
+    }),
+    [scene, quadGeometry]
+  );
+  const glLike = useMemo2(
+    () => ({
+      setRenderTarget: (t) => gl.setRenderTarget(t),
+      clear: () => {
+        gl.setClearColor(0, 0);
+        gl.clear(true, true, false);
+      },
+      render: (s, c) => gl.render(s, c),
+      setPixelRatio: (n) => gl.setPixelRatio(n),
+      getPixelRatio: () => gl.getPixelRatio()
+    }),
+    [gl]
+  );
+  useEffect3(() => {
+    bridge.setInvalidate(() => invalidate());
+    return () => bridge.setInvalidate(null);
+  }, [bridge, invalidate]);
+  useEffect3(() => {
+    const quadMap = quadsRef.current;
+    return () => {
+      for (const mesh of quadMap.values()) {
+        scene.remove(mesh);
+        mesh.material.dispose();
+      }
+      quadMap.clear();
+      pool.dispose();
+      for (const [key] of bridge.state.all()) bridge.state.markEvicted(key);
+    };
+  }, [scene, pool, bridge]);
+  useFrame((_, delta) => {
+    bridge.renderAssert.begin();
+    let stats;
+    try {
+      stats = runCompositorPass({
+        world,
+        bridge,
+        pool,
+        quads,
+        gl: glLike,
+        compCamera: {
+          raw: compCamera,
+          // the REAL camera — gl.render instanceof-checks it
+          setFrustum: (f) => {
+            compCamera.left = f.left;
+            compCamera.right = f.right;
+            compCamera.top = f.top;
+            compCamera.bottom = f.bottom;
+            compCamera.position.set(f.x, f.y, 1e3);
+            compCamera.updateProjectionMatrix();
+          }
+        },
+        islandCamera: (entity) => {
+          const handle = bridge.islandFor(entity);
+          if (handle === void 0) return void 0;
+          return {
+            setFrustum: (halfW, halfH) => {
+              handle.camera.left = -halfW;
+              handle.camera.right = halfW;
+              handle.camera.top = halfH;
+              handle.camera.bottom = -halfH;
+              handle.camera.updateProjectionMatrix();
+            }
+          };
+        },
+        compositeScene: scene,
+        maxFboBytes,
+        maxRepaintsPerFrame,
+        dtMs: delta * 1e3
+      });
+    } finally {
+      bridge.renderAssert.end();
+    }
+    if (stats.anyHot || stats.pendingPaints > 0) invalidate();
+  }, 1);
+  const entries = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+  const islands = [];
+  for (const entry of entries) {
+    if (entry.hidden) continue;
+    if (!world.isAlive(entry.entity)) continue;
+    const type = world.get(entry.entity, PrefabId)?.id;
+    const widget = typeof type === "string" ? widgets.get(type) : void 0;
+    if (widget === void 0 || widget.surface !== "gl") continue;
+    islands.push(
+      createElement2(Island, {
+        key: String(entry.entity),
+        bridge,
+        world,
+        entity: entry.entity,
+        widget,
+        ...environment !== void 0 ? { environment } : {}
+      })
+    );
+  }
+  return createElement2("group", null, islands);
+}
+
+// ../r3f/src/resource-registry.ts
+var ResourceRegistry = class {
+  geometries = /* @__PURE__ */ new Map();
+  materials = /* @__PURE__ */ new Map();
+  textures = /* @__PURE__ */ new Map();
+  disposed = false;
+  acquireGeometry(key, factory) {
+    const existing = this.geometries.get(key);
+    if (existing) {
+      existing.refCount++;
+      return existing.resource;
+    }
+    const resource = factory();
+    this.geometries.set(key, { resource, refCount: 1 });
+    return resource;
+  }
+  releaseGeometry(key) {
+    this.releaseFrom(this.geometries, key);
+  }
+  acquireMaterial(key, factory) {
+    const existing = this.materials.get(key);
+    if (existing) {
+      existing.refCount++;
+      return existing.resource;
+    }
+    const resource = factory();
+    this.materials.set(key, { resource, refCount: 1 });
+    return resource;
+  }
+  releaseMaterial(key) {
+    this.releaseFrom(this.materials, key);
+  }
+  acquireTexture(key, factory) {
+    const existing = this.textures.get(key);
+    if (existing) {
+      existing.refCount++;
+      return existing.resource;
+    }
+    const resource = factory();
+    this.textures.set(key, { resource, refCount: 1 });
+    return resource;
+  }
+  releaseTexture(key) {
+    this.releaseFrom(this.textures, key);
+  }
+  /** Number of distinct shared geometries currently held. */
+  geometryCount() {
+    return this.geometries.size;
+  }
+  /** Number of distinct shared materials currently held. */
+  materialCount() {
+    return this.materials.size;
+  }
+  /** Number of distinct shared textures currently held. */
+  textureCount() {
+    return this.textures.size;
+  }
+  /**
+   * 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() {
+    let total = 0;
+    for (const { resource } of this.geometries.values()) {
+      for (const attr of Object.values(resource.attributes)) {
+        if ("array" in attr && attr.array.byteLength) {
+          total += attr.array.byteLength;
+        }
+      }
+      if (resource.index) {
+        total += resource.index.array.byteLength;
+      }
+    }
+    return total;
+  }
+  /** Dispose every resource and clear the registry. */
+  dispose() {
+    if (this.disposed) return;
+    for (const { resource } of this.geometries.values()) resource.dispose();
+    for (const { resource } of this.materials.values()) resource.dispose();
+    for (const { resource } of this.textures.values()) resource.dispose();
+    this.geometries.clear();
+    this.materials.clear();
+    this.textures.clear();
+    this.disposed = true;
+  }
+  /** True after `dispose()` — callers should re-create the registry instead of using it. */
+  isDisposed() {
+    return this.disposed;
+  }
+  releaseFrom(map, key) {
+    const entry = map.get(key);
+    if (!entry) return;
+    entry.refCount--;
+    if (entry.refCount <= 0) {
+      queueMicrotask(() => {
+        const current = map.get(key);
+        if (current && current.refCount <= 0) {
+          current.resource.dispose();
+          map.delete(key);
+        }
+      });
+    }
+  }
+};
+
+// ../r3f/src/gl-router.ts
+import { Raycaster, Vector2 } from "three";
+function handlersOf(obj) {
+  const inst = obj.__r3f;
+  if (inst === void 0 || (inst.eventCount ?? 0) === 0) return void 0;
+  return inst.handlers;
+}
+function createGLPointerRouter({ world, bridge, index }) {
+  const raycaster = new Raycaster();
+  const ndc = new Vector2();
+  const captures = /* @__PURE__ */ new Map();
+  const hovered = /* @__PURE__ */ new Map();
+  const unclaimedDowns = /* @__PURE__ */ new Map();
+  const castAt = (screenX, screenY) => {
+    const cam = world.getResource(Camera);
+    if (cam === void 0) return void 0;
+    const w = screenToWorld(screenX, screenY, cam);
+    const hit = pickTopAt(world, index, w.x, w.y, 0);
+    if (hit === void 0) return void 0;
+    const type = world.get(hit, PrefabId)?.id;
+    const widget = typeof type === "string" ? widgets.get(type) : void 0;
+    if (widget === void 0 || widget.surface !== "gl") return void 0;
+    const handle = bridge.islandFor(hit);
+    const pos = world.get(hit, Position);
+    const size = world.get(hit, Size);
+    if (handle === void 0 || pos === void 0 || size === void 0 || size.w <= 0 || size.h <= 0) {
+      return void 0;
+    }
+    const local = worldToIsland(w.x, w.y, { x: pos.x, y: pos.y, width: size.w, height: size.h });
+    ndc.set(local.x / (size.w / 2), local.y / (size.h / 2));
+    const cam3 = handle.camera;
+    cam3.left = -size.w / 2;
+    cam3.right = size.w / 2;
+    cam3.top = size.h / 2;
+    cam3.bottom = -size.h / 2;
+    cam3.updateProjectionMatrix();
+    cam3.updateMatrixWorld(true);
+    handle.scene.updateMatrixWorld(true);
+    raycaster.setFromCamera(ndc, cam3);
+    return { entity: hit, hits: raycaster.intersectObjects(handle.scene.children, true) };
+  };
+  const dispatch = (type, eventType, entity, hits, native, only) => {
+    const visited = /* @__PURE__ */ new Set();
+    let stopped = false;
+    let claimedBy;
+    const targets = [];
+    if (hits.length === 0 && only !== void 0) {
+      targets.push({ obj: only, hit: void 0 });
+    }
+    for (const hit of hits) {
+      for (let obj = hit.object; obj !== null; obj = obj.parent) {
+        if (visited.has(obj)) continue;
+        visited.add(obj);
+        targets.push({ obj, hit });
+      }
+    }
+    for (const { obj, hit } of targets) {
+      const fn = handlersOf(obj)?.[type];
+      if (fn === void 0) continue;
+      let localStop = false;
+      const ev = {
+        type: eventType,
+        nativeEvent: native,
+        point: hit?.point,
+        distance: hit?.distance ?? 0,
+        object: hit?.object ?? obj,
+        eventObject: obj,
+        intersections: hits,
+        entity,
+        stopPropagation() {
+          localStop = true;
+        },
+        get stopped() {
+          return localStop;
+        }
+      };
+      fn(ev);
+      if (localStop) {
+        stopped = true;
+        claimedBy = obj;
+        break;
+      }
+    }
+    return { stopped, claimedBy };
+  };
+  const syncHover = (now, native) => {
+    const nowEntity = now?.entity;
+    const nowObjs = /* @__PURE__ */ new Set();
+    if (now !== void 0) {
+      for (const hit of now.hits) {
+        for (let obj = hit.object; obj !== null; obj = obj.parent) nowObjs.add(obj);
+      }
+    }
+    for (const [entity, prev] of hovered) {
+      const gone = [];
+      for (const obj of prev) {
+        if (entity !== nowEntity || !nowObjs.has(obj)) gone.push(obj);
+      }
+      for (const obj of gone) {
+        prev.delete(obj);
+        handlersOf(obj)?.onPointerOut?.({
+          type: "pointerout",
+          nativeEvent: native,
+          point: void 0,
+          distance: 0,
+          object: obj,
+          eventObject: obj,
+          intersections: [],
+          entity,
+          stopPropagation() {
+          },
+          stopped: false
+        });
+      }
+      if (prev.size === 0) hovered.delete(entity);
+    }
+    if (now !== void 0 && nowEntity !== void 0) {
+      let set = hovered.get(nowEntity);
+      if (set === void 0) {
+        set = /* @__PURE__ */ new Set();
+        hovered.set(nowEntity, set);
+      }
+      for (const obj of nowObjs) {
+        if (set.has(obj) || handlersOf(obj) === void 0) continue;
+        set.add(obj);
+        handlersOf(obj)?.onPointerOver?.({
+          type: "pointerover",
+          nativeEvent: native,
+          point: void 0,
+          distance: 0,
+          object: obj,
+          eventObject: obj,
+          intersections: now.hits,
+          entity: nowEntity,
+          stopPropagation() {
+          },
+          stopped: false
+        });
+      }
+    }
+  };
+  return {
+    route(kind, screenX, screenY, native) {
+      if (kind === "down") {
+        const cast2 = castAt(screenX, screenY);
+        if (cast2 === void 0) {
+          unclaimedDowns.delete(native.pointerId);
+          return false;
+        }
+        const { stopped, claimedBy } = dispatch("onPointerDown", "pointerdown", cast2.entity, cast2.hits, native);
+        if (stopped) {
+          unclaimedDowns.delete(native.pointerId);
+          captures.set(native.pointerId, { entity: cast2.entity, downObject: claimedBy });
+          return true;
+        }
+        const top = cast2.hits[0]?.object;
+        if (top !== void 0) unclaimedDowns.set(native.pointerId, { entity: cast2.entity, object: top });
+        return false;
+      }
+      const capture = captures.get(native.pointerId);
+      if (kind === "move") {
+        if (capture !== void 0) {
+          const cast2 = castAt(screenX, screenY);
+          const hits2 = cast2 !== void 0 && cast2.entity === capture.entity ? cast2.hits : [];
+          dispatch("onPointerMove", "pointermove", capture.entity, hits2, native, capture.downObject);
+          return true;
+        }
+        if (native.buttons === 0) {
+          const cast2 = castAt(screenX, screenY);
+          syncHover(cast2, native);
+          if (cast2 !== void 0) {
+            dispatch("onPointerMove", "pointermove", cast2.entity, cast2.hits, native);
+          }
+        }
+        return false;
+      }
+      if (capture === void 0) {
+        const pending = unclaimedDowns.get(native.pointerId);
+        unclaimedDowns.delete(native.pointerId);
+        if (kind === "up" && pending !== void 0) {
+          const cast2 = castAt(screenX, screenY);
+          if (cast2 !== void 0 && cast2.entity === pending.entity && cast2.hits[0]?.object === pending.object) {
+            dispatch("onClick", "click", cast2.entity, cast2.hits, native, pending.object);
+          }
+        }
+        return false;
+      }
+      captures.delete(native.pointerId);
+      const cast = castAt(screenX, screenY);
+      const hits = cast !== void 0 && cast.entity === capture.entity ? cast.hits : [];
+      if (kind === "up") {
+        const { claimedBy } = dispatch("onPointerUp", "pointerup", capture.entity, hits, native, capture.downObject);
+        const clickTarget = claimedBy ?? capture.downObject;
+        if (clickTarget !== void 0 && clickTarget === capture.downObject) {
+          dispatch("onClick", "click", capture.entity, hits, native, clickTarget);
+        }
+      } else {
+        dispatch("onPointerCancel", "pointercancel", capture.entity, hits, native, capture.downObject);
+      }
+      return true;
+    }
+  };
+}
+export {
+  CompositeMaterial,
+  GLViews,
+  Island,
+  IslandContext,
+  RenderTargetPool,
+  ResourceRegistry,
+  createGLBridge,
+  createGLPointerRouter,
+  createIslandStateStore,
+  createRenderWriteTrap,
+  runCompositorPass,
+  useIslandContext,
+  useIslandFrame,
+  useIslandInvalidate,
+  useIslandLift
+};
+//# sourceMappingURL=r3f.js.map