@vibecook/ice 0.11.0 → 0.14.0

package/dist/r3f.js

@@ -1,1644 +0,0 @@
-import {
-  EngineProvider,
-  hasPreviewSnapshot,
-  setPreviewSnapshot
-} from "./chunk-Q665T4L7.js";
-import "./chunk-2TNVB2ON.js";
-import {
-  Active,
-  Camera,
-  Culled,
-  GESTURE_DEFAULTS,
-  GestureSettings,
-  Grab,
-  Opacity,
-  Position,
-  PrefabId,
-  RUNTIME_BUDGETS,
-  Size,
-  StackZ,
-  StageMode,
-  Viewport,
-  Visible,
-  createCanvasEngine,
-  createSiblingOrderIndex,
-  defineQuery,
-  navFlightActive,
-  pickTopAt,
-  widgets
-} from "./chunk-VGVDJZSP.js";
-import {
-  compositeCameraFrustum,
-  computeIslandPhase,
-  cubicBezierEase,
-  fboPixelSize,
-  isOutOfBand,
-  screenToWorld,
-  selectBand,
-  selectEvictions,
-  worldRectToComposite,
-  worldToIsland
-} from "./chunk-OR5FNVUE.js";
-
-// ../r3f/src/island-state.ts
-var LIFT_DEFAULT_MS = 180;
-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,
-        pendingDtMs: 0,
-        compositeScale: 1,
-        liftTarget: 1,
-        liftFrom: 1,
-        liftElapsedMs: 0,
-        liftMs: 0,
-        compositeOpacity: 1,
-        opacityTarget: 1,
-        opacityFrom: 1,
-        opacityElapsedMs: 0,
-        opacityMs: 0
-      };
-      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);
-  const now = opts.now ?? (() => performance.now());
-  let renderNow = null;
-  let wantsFrame = false;
-  let animDueAt = null;
-  let rendering = false;
-  const requestFrame = () => {
-    wantsFrame = true;
-  };
-  const removeReflector = engine.registerReflector({
-    name: "r3fInvalidator",
-    // StageMode: a background-hold flip must re-fire the pass — freezing on
-    // take, and (critically) REPAINTING Hot islands on release. The observe
-    // list also keeps strata enforcement armed (a rig must observe — the
-    // always-flush advance reflector below deliberately observes nothing).
-    observe: { resources: [Camera, Viewport, StageMode] },
-    flush: () => requestFrame()
-  });
-  const removeAdvanceReflector = engine.registerReflector({
-    name: "r3fAdvance",
-    always: true,
-    flush: () => {
-      if (rendering) return;
-      const t = now();
-      if (!wantsFrame && (animDueAt === null || t < animDueAt)) return;
-      if (renderNow === null) return;
-      wantsFrame = false;
-      animDueAt = null;
-      rendering = true;
-      try {
-        renderNow(t);
-      } finally {
-        rendering = false;
-      }
-    }
-  });
-  const order = createSiblingOrderIndex(world);
-  const removeOrderObserver = order.observe(() => {
-    if (order.stale()) 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,
-    order,
-    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 changed, texture still good (order
-        // dirt is bridge-scoped: the ChildOf reorder wake above):
-        world.reactive.observeValue(entity, Position, () => requestFrame()),
-        // composite dirt — the durable Opacity cell rides the quad's uOpacity,
-        // never the island's FBO (a fade must not repaint the content):
-        world.reactive.observeValue(entity, Opacity, () => 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, durationMs = LIFT_DEFAULT_MS) {
-      const s = state.ensure(entity);
-      if (s.liftTarget === scale) return;
-      s.liftTarget = scale;
-      if (durationMs <= 0) {
-        s.compositeScale = scale;
-        s.liftMs = 0;
-        s.liftElapsedMs = 0;
-      } else {
-        s.liftFrom = s.compositeScale;
-        s.liftMs = durationMs;
-        s.liftElapsedMs = 0;
-      }
-      requestFrame();
-    },
-    setCompositeOpacity(entity, opacity, durationMs = LIFT_DEFAULT_MS) {
-      const s = state.ensure(entity);
-      if (s.opacityTarget === opacity) return;
-      s.opacityTarget = opacity;
-      if (durationMs <= 0) {
-        s.compositeOpacity = opacity;
-        s.opacityMs = 0;
-        s.opacityElapsedMs = 0;
-      } else {
-        s.opacityFrom = s.compositeOpacity;
-        s.opacityMs = durationMs;
-        s.opacityElapsedMs = 0;
-      }
-      requestFrame();
-    },
-    setRenderNow(fn) {
-      renderNow = fn;
-    },
-    schedulePass(plan) {
-      if (plan === "now") {
-        wantsFrame = true;
-        animDueAt = null;
-      } else if (plan === "none") {
-        animDueAt = null;
-      } else {
-        animDueAt = now() + plan;
-      }
-    },
-    uninstall() {
-      removeReflector();
-      removeAdvanceReflector();
-      removeOrderObserver();
-      removeWorldObserver();
-      renderAssert.dispose();
-      islands.clear();
-      frameCbs.clear();
-      state.clear();
-      renderNow = null;
-      wantsFrame = false;
-      animDueAt = null;
-    }
-  };
-}
-
-// ../r3f/src/compositor-pass.ts
-var GRABBED_RENDER_ORDER = 1e9;
-var LIFT_EASE = cubicBezierEase(0.2, 0.9, 0.3, 1.2);
-var OPACITY_EASE = cubicBezierEase(0.25, 0.1, 0.25, 1);
-function runCompositorPass(ctx) {
-  const { world, bridge, pool, quads, gl } = ctx;
-  const stats = {
-    repainted: 0,
-    pendingPaints: 0,
-    evicted: 0,
-    fboBytes: 0,
-    anyHot: false,
-    liftAnimating: false
-  };
-  const cam = world.getResource(Camera);
-  const vp = world.getResource(Viewport);
-  if (cam === void 0 || vp === void 0 || vp.w === 0) return stats;
-  const inFlight2 = navFlightActive(world);
-  const inMotion = cam.gesturing || inFlight2;
-  const backgrounded = (world.getResource(StageMode)?.backgroundHolds ?? 0) > 0;
-  const frozen = inFlight2 || backgrounded;
-  ctx.compCamera.setFrustum(compositeCameraFrustum(cam, vp.w, vp.h));
-  const idleDpr = vp.dpr > 0 ? vp.dpr : 1;
-  const targetDpr = inMotion ? Math.min(idleDpr, 1) : idleDpr;
-  if (gl.getPixelRatio() !== targetDpr) gl.setPixelRatio(targetDpr);
-  const phaseOf = (e) => {
-    const alive = world.isAlive(e);
-    const active = alive && world.hasTag(e, Active);
-    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(active, 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 = Math.min(gl.getPixelRatio(), ctx.maxPaintDpr) * 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 = !inMotion && s.fboGeneration >= 0 && isOutOfBand(cam.zoom, s.paintedAt.band);
-    const paintable = frozen ? wantsPhase && s.fboGeneration < 0 : wantsPhase || genDirty || bandStale;
-    if (paintable) {
-      toPaint.push(e);
-      if (s.phase === "Hot") s.pendingDtMs += ctx.dtMs;
-    }
-  }
-  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") {
-      const owedMs = s.pendingDtMs;
-      s.pendingDtMs = 0;
-      for (const cb of bridge.frameCallbacksFor(e)) cb(owedMs);
-    }
-    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);
-  }
-  const hasChrome = (e) => {
-    const type = world.get(e, PrefabId)?.id;
-    return typeof type === "string" && widgets.get(type)?.chrome != null;
-  };
-  const composited = [];
-  let clip = null;
-  const ordinals = bridge.order.ordinals();
-  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 (s.phase === "Dormant" || 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 });
-    if (s.liftElapsedMs < s.liftMs) {
-      s.liftElapsedMs += ctx.dtMs;
-      const t = Math.min(1, s.liftElapsedMs / s.liftMs);
-      s.compositeScale = t >= 1 ? s.liftTarget : s.liftFrom + (s.liftTarget - s.liftFrom) * LIFT_EASE(t);
-      if (t < 1) stats.liftAnimating = true;
-    }
-    if (s.opacityElapsedMs < s.opacityMs) {
-      s.opacityElapsedMs += ctx.dtMs;
-      const t = Math.min(1, s.opacityElapsedMs / s.opacityMs);
-      s.compositeOpacity = t >= 1 ? s.opacityTarget : s.opacityFrom + (s.opacityTarget - s.opacityFrom) * OPACITY_EASE(t);
-      if (t < 1) stats.liftAnimating = true;
-    }
-    const lift = s.compositeScale;
-    quad.setTransform(q.x, q.y, q.sx * lift, q.sy * lift);
-    quad.setTexture(fbo.texture);
-    const baseOpacity = world.get(e, Opacity)?.a ?? 1;
-    quad.setOpacity(Math.min(1, Math.max(0, baseOpacity * s.compositeOpacity)));
-    const grabbed = world.get(e, Grab) !== void 0;
-    quad.setRenderOrder(
-      grabbed || lift !== 1 ? GRABBED_RENDER_ORDER : ordinals.get(e) ?? world.get(e, StackZ)?.z ?? 0
-    );
-    quad.setVisible(true);
-    pool.touch(e);
-    composited.push({ key: e, quad });
-    if (clip === null && grabbed && hasChrome(e)) {
-      const hw = q.sx * lift / 2;
-      const hh = q.sy * lift / 2;
-      clip = { key: e, minX: q.x - hw, minY: q.y - hh, maxX: q.x + hw, maxY: q.y + hh };
-    }
-  }
-  for (const { key, quad } of composited) {
-    if (clip === null) quad.setDragClip(0, 0, 0, 0, false);
-    else quad.setDragClip(clip.minX, clip.minY, clip.maxX, clip.maxY, key === clip.key);
-  }
-  gl.setRenderTarget(null);
-  gl.clear();
-  gl.render(ctx.compositeScene, ctx.compCamera.raw);
-  stats.fboBytes = pool.bytesUsed();
-  if (backgrounded) stats.anyHot = false;
-  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;
-varying vec2 vWorld;
-void main() {
-  vUv = uv;
-  vWorld = (modelMatrix * vec4(position, 1.0)).xy;
-  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-}
-`
-);
-var FRAGMENT_SHADER = (
-  /* glsl */
-  `
-uniform sampler2D map;
-uniform float uOpacity;
-uniform vec4 uDraggedRect;
-uniform float uIsDragged;
-varying vec2 vUv;
-varying vec2 vWorld;
-
-void main() {
-  // Drag clip (v1 RFC-003, composite-space): while a chrome-carrying GL card
-  // is dragged, every OTHER quad discards fragments inside its rect so the
-  // card's P1 DOM chrome shows through. (0,0,0,0) rect \u21D2 measure-zero, off.
-  if (uIsDragged < 0.5 &&
-      vWorld.x >= uDraggedRect.x && vWorld.x <= uDraggedRect.z &&
-      vWorld.y >= uDraggedRect.y && vWorld.y <= uDraggedRect.w) {
-    discard;
-  }
-  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;
-  draggedRectUniform;
-  isDraggedUniform;
-  constructor() {
-    const uniforms = {
-      map: { value: null },
-      uOpacity: { value: 1 },
-      // three uploads number[] as vec4 — no Vector4 allocation needed.
-      uDraggedRect: { value: [0, 0, 0, 0] },
-      uIsDragged: { value: 0 }
-    };
-    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;
-    this.draggedRectUniform = uniforms.uDraggedRect;
-    this.isDraggedUniform = uniforms.uIsDragged;
-  }
-  /** 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;
-  }
-  /**
-   * 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, minY, maxX, maxY) {
-    const r = this.draggedRectUniform.value;
-    r[0] = minX;
-    r[1] = minY;
-    r[2] = maxX;
-    r[3] = maxY;
-  }
-  /** True on the dragged card's own quad — exempt from the clip. */
-  setIsDragged(isDragged) {
-    this.isDraggedUniform.value = isDragged ? 1 : 0;
-  }
-  // 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, durationMs) {
-  const { bridge, entity } = useIslandContext();
-  useEffect(() => {
-    bridge.setCompositeScale(entity, scale, durationMs);
-  }, [bridge, entity, scale, durationMs]);
-  useEffect(() => () => bridge.setCompositeScale(entity, 1), [bridge, entity]);
-}
-function useIslandOpacity(opacity, durationMs) {
-  const { bridge, entity } = useIslandContext();
-  useEffect(() => {
-    bridge.setCompositeOpacity(entity, opacity, durationMs);
-  }, [bridge, entity, opacity, durationMs]);
-  useEffect(() => () => bridge.setCompositeOpacity(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 DEPTH_BYTES_PER_PIXEL = 4;
-var SAMPLES = 4;
-function targetBytes(pixelWidth, pixelHeight) {
-  const msaa = SAMPLES > 1;
-  const colorBytes = COLOR_BYTES_PER_PIXEL * (msaa ? 1 + SAMPLES : 1);
-  const depthBytes = DEPTH_BYTES_PER_PIXEL * (msaa ? SAMPLES : 1);
-  return pixelWidth * pixelHeight * (colorBytes + depthBytes);
-}
-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/self-sustain.ts
-var RATE_CAP_SLACK_MS = 4;
-function selfSustainPlan(stats, elapsedMs, maxFps) {
-  if (stats.liftAnimating) return "now";
-  if (!stats.anyHot && stats.pendingPaints <= 0) return "none";
-  const interval = 1e3 / Math.max(1, maxFps);
-  const delay = interval - elapsedMs - RATE_CAP_SLACK_MS;
-  return delay <= 0 ? "now" : delay;
-}
-
-// ../r3f/src/gl-root.tsx
-var visibleWidgetsQ = defineQuery([Visible]);
-var culledWidgetsQ = defineQuery([Culled]);
-function GLViews({
-  engine,
-  bridge,
-  store,
-  maxFboBytes = RUNTIME_BUDGETS.fboBytes,
-  maxRepaintsPerFrame = 4,
-  maxAnimationFps = 60,
-  maxPaintDpr = 1.5,
-  environment,
-  onFrameStats
-}) {
-  const world = engine.world;
-  const gl = useThree((s) => s.gl);
-  const scene = useThree((s) => s.scene);
-  const set = useThree((s) => s.set);
-  const advance2 = useThree((s) => s.advance);
-  const frameloop = useThree((s) => s.frameloop);
-  const clock = useThree((s) => s.clock);
-  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;
-          },
-          setOpacity: (o) => m.material.setOpacity(o),
-          setDragClip: (minX, minY, maxX, maxY, exempt) => {
-            const mat = m.material;
-            mat.setDraggedRect(minX, minY, maxX, maxY);
-            mat.setIsDragged(exempt);
-          }
-        };
-      },
-      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(() => {
-    clock.elapsedTime = performance.now() / 1e3;
-    bridge.setRenderNow((nowMs) => advance2(nowMs / 1e3, true));
-    return () => bridge.setRenderNow(null);
-  }, [bridge, advance2, clock]);
-  useEffect3(() => {
-    if (frameloop !== "never") {
-      console.warn(
-        `[ice/r3f] GLViews: <Canvas frameloop="${frameloop}"> \u2014 use frameloop="never". The engine drives frames (reflect-phase advance); a self-scheduling loop renders out of phase with the DOM planes.`
-      );
-    }
-  }, [frameloop]);
-  const statsCbRef = useRef2(onFrameStats);
-  statsCbRef.current = onFrameStats;
-  const paintsOwedRef = useRef2(false);
-  const gpuProfilerRef = useRef2(null);
-  const gpuProfilerState = useRef2("idle");
-  useEffect3(
-    () => () => {
-      gpuProfilerRef.current?.dispose();
-      gpuProfilerRef.current = null;
-      gpuProfilerState.current = "idle";
-    },
-    []
-  );
-  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) => {
-    const profiling = statsCbRef.current !== void 0;
-    if (profiling) {
-      if (gpuProfilerState.current === "idle") {
-        gpuProfilerState.current = "loading";
-        void import("stats-gl").then(async ({ StatsProfiler }) => {
-          const p = new StatsProfiler({ trackGPU: true });
-          await p.init(gl);
-          gpuProfilerRef.current = p;
-          gpuProfilerState.current = "ready";
-        }).catch(() => {
-          gpuProfilerState.current = "failed";
-        });
-      }
-      gl.info.autoReset = false;
-      gl.info.reset();
-    } else if (!gl.info.autoReset) {
-      gl.info.autoReset = true;
-    }
-    const passStart = performance.now();
-    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,
-        maxPaintDpr,
-        dtMs: delta * 1e3
-      });
-    } finally {
-      bridge.renderAssert.end();
-    }
-    const cb = statsCbRef.current;
-    if (cb !== void 0) {
-      const gpu = gpuProfilerRef.current;
-      gpu?.update();
-      const d = gpu?.getData();
-      const info = gl.info;
-      let total = 0;
-      let hot = 0;
-      let warm = 0;
-      let waking = 0;
-      let cold = 0;
-      let dormant = 0;
-      let pixels = 0;
-      const bandHistogram = {};
-      for (const [e, s] of bridge.state.all()) {
-        total++;
-        if (s.phase === "Hot") hot++;
-        else if (s.phase === "Warm") warm++;
-        else if (s.phase === "Waking") waking++;
-        else if (s.phase === "Dormant") dormant++;
-        else cold++;
-        if (s.fboGeneration >= 0 && pool.get(e) !== null) {
-          pixels += s.paintedAt.w * s.paintedAt.h;
-          const key = `\xD7${s.paintedAt.band}`;
-          bandHistogram[key] = (bandHistogram[key] ?? 0) + 1;
-        }
-      }
-      let visibleWidgets = 0;
-      let culledWidgets = 0;
-      world.query(visibleWidgetsQ).each((b) => {
-        visibleWidgets += b.count;
-      });
-      world.query(culledWidgetsQ).each((b) => {
-        culledWidgets += b.count;
-      });
-      const zoom = world.getResource(Camera)?.zoom ?? 1;
-      const band = selectBand(zoom);
-      cb({
-        cpuMs: performance.now() - passStart,
-        gpuMs: d?.gpu ?? 0,
-        fps: d?.fps ?? 0,
-        drawCalls: info.render.calls,
-        triangles: info.render.triangles,
-        points: info.render.points,
-        lines: info.render.lines,
-        programs: info.programs?.length ?? 0,
-        geometries: info.memory.geometries,
-        textures: info.memory.textures,
-        renderTargets: pool.size(),
-        renderMegaPixels: pixels / 1e6,
-        fboBytes: pool.bytesUsed(),
-        fboBudgetBytes: maxFboBytes,
-        islands: { total, hot, warm, waking, cold, dormant },
-        bandHistogram,
-        repainted: stats.repainted,
-        pendingPaints: stats.pendingPaints,
-        evicted: stats.evicted,
-        zoom,
-        band,
-        effectiveDpr: Math.min(gl.getPixelRatio(), maxPaintDpr) * band,
-        visibleWidgets,
-        culledWidgets
-      });
-    }
-    bridge.schedulePass(selfSustainPlan(stats, performance.now() - passStart, maxAnimationFps));
-    paintsOwedRef.current = stats.pendingPaints > 0 || stats.liftAnimating;
-  }, 1);
-  useEffect3(
-    () => engine.frame.settleWhile("gl-paints", () => paintsOwedRef.current),
-    [engine]
-  );
-  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) {
-    if (this.disposed) {
-      throw new Error("ResourceRegistry: cannot acquire after dispose");
-    }
-    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) {
-    if (this.disposed) {
-      throw new Error("ResourceRegistry: cannot acquire after dispose");
-    }
-    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) {
-    if (this.disposed) {
-      throw new Error("ResourceRegistry: cannot acquire after dispose");
-    }
-    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 routerOrder = createSiblingOrderIndex(world);
-  const captures = /* @__PURE__ */ new Map();
-  const hovered = /* @__PURE__ */ new Map();
-  const unclaimedDowns = /* @__PURE__ */ new Map();
-  let hoverInteractive = false;
-  const chainInteractive = (hits) => {
-    for (const h of hits) {
-      for (let obj = h.object; obj !== null; obj = obj.parent) {
-        const handlers = handlersOf(obj);
-        if (handlers !== void 0 && (handlers.onPointerDown !== void 0 || handlers.onClick !== void 0)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-  const withinTapSlop = (downX, downY, upX, upY) => {
-    const slop = world.getResource(GestureSettings)?.tapSlopPx ?? GESTURE_DEFAULTS.tapSlopPx;
-    const dx = upX - downX;
-    const dy = upY - downY;
-    return dx * dx + dy * dy <= slop * slop;
-  };
-  const chainHas = (hits, target) => {
-    for (const h of hits) {
-      for (let obj = h.object; obj !== null; obj = obj.parent) {
-        if (obj === target) return true;
-      }
-    }
-    return false;
-  };
-  const filterToChain = (hits, target) => {
-    const kept = [];
-    for (const h of hits) {
-      for (let obj = h.object; obj !== null; obj = obj.parent) {
-        if (obj === target) {
-          kept.push(h);
-          break;
-        }
-      }
-    }
-    return kept;
-  };
-  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, void 0, routerOrder.ordinals());
-    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 captureHits = (x, y, capture) => {
-    const cast = castAt(x, y);
-    if (cast === void 0 || cast.entity !== capture.entity) return [];
-    return capture.downObject === void 0 ? cast.hits : filterToChain(cast.hits, capture.downObject);
-  };
-  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 cast = castAt(screenX, screenY);
-        if (cast === void 0) {
-          unclaimedDowns.delete(native.pointerId);
-          return false;
-        }
-        const { stopped, claimedBy } = dispatch("onPointerDown", "pointerdown", cast.entity, cast.hits, native);
-        if (stopped) {
-          unclaimedDowns.delete(native.pointerId);
-          captures.set(native.pointerId, {
-            entity: cast.entity,
-            downObject: claimedBy,
-            downX: screenX,
-            downY: screenY
-          });
-          return true;
-        }
-        const top = cast.hits[0]?.object;
-        if (top !== void 0) {
-          unclaimedDowns.set(native.pointerId, {
-            entity: cast.entity,
-            object: top,
-            downX: screenX,
-            downY: screenY
-          });
-        }
-        return false;
-      }
-      const capture = captures.get(native.pointerId);
-      if (kind === "move") {
-        if (capture !== void 0) {
-          hoverInteractive = true;
-          const hits2 = captureHits(screenX, screenY, capture);
-          dispatch("onPointerMove", "pointermove", capture.entity, hits2, native, capture.downObject);
-          return true;
-        }
-        hoverInteractive = false;
-        if (native.buttons === 0) {
-          const cast = castAt(screenX, screenY);
-          hoverInteractive = cast !== void 0 && chainInteractive(cast.hits);
-          syncHover(cast, native);
-          if (cast !== void 0) {
-            dispatch("onPointerMove", "pointermove", cast.entity, cast.hits, native);
-          }
-        }
-        return false;
-      }
-      if (capture === void 0) {
-        const pending = unclaimedDowns.get(native.pointerId);
-        unclaimedDowns.delete(native.pointerId);
-        if (kind === "up" && pending !== void 0 && withinTapSlop(pending.downX, pending.downY, screenX, screenY)) {
-          const cast = castAt(screenX, screenY);
-          if (cast !== void 0 && cast.entity === pending.entity && cast.hits[0]?.object === pending.object) {
-            dispatch("onClick", "click", cast.entity, cast.hits, native, pending.object);
-          }
-        }
-        return false;
-      }
-      captures.delete(native.pointerId);
-      const hits = captureHits(screenX, screenY, capture);
-      if (kind === "up") {
-        const { claimedBy } = dispatch("onPointerUp", "pointerup", capture.entity, hits, native, capture.downObject);
-        if (capture.downObject !== void 0 && (claimedBy === void 0 || claimedBy === capture.downObject) && chainHas(hits, capture.downObject) && withinTapSlop(capture.downX, capture.downY, screenX, screenY)) {
-          dispatch("onClick", "click", capture.entity, hits, native, capture.downObject);
-        }
-      } else {
-        dispatch("onPointerCancel", "pointercancel", capture.entity, hits, native, capture.downObject);
-      }
-      return true;
-    },
-    overInteractive: () => hoverInteractive
-  };
-}
-
-// ../r3f/src/preview-capture.tsx
-import { advance, createRoot } from "@react-three/fiber";
-import { createElement as createElement3 } from "react";
-var sandbox = null;
-function ensureEntity(def) {
-  if (sandbox === null) {
-    const ce = createCanvasEngine();
-    ce.docs.create();
-    ce.world.sync();
-    ce.step(16);
-    sandbox = { ce, entities: /* @__PURE__ */ new Map() };
-  }
-  const hit = sandbox.entities.get(def.type);
-  if (hit !== void 0) return hit;
-  try {
-    const e = sandbox.ce.ops.spawnWidget(def.type, {
-      x: 0,
-      y: 0,
-      undoable: false,
-      ...def.previewProps !== void 0 ? { props: def.previewProps } : {}
-    });
-    sandbox.ce.world.sync();
-    sandbox.ce.step(32);
-    sandbox.entities.set(def.type, e);
-    return e;
-  } catch (err) {
-    console.warn(`ice: preview capture \u2014 sandbox spawn failed for "${def.type}".`, err);
-    return void 0;
-  }
-}
-function stubBridge(callbacks) {
-  const stub = {
-    addFrameCallback: (_e, cb) => {
-      callbacks.add(cb);
-      return () => callbacks.delete(cb);
-    },
-    bumpPaint: () => {
-    },
-    setCompositeScale: () => {
-    },
-    setCompositeOpacity: () => {
-    }
-  };
-  return stub;
-}
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-var inFlight = null;
-function captureWidgetPreviews(opts = {}) {
-  if (inFlight !== null) return inFlight;
-  const run = doCapture(opts).finally(() => {
-    inFlight = null;
-  });
-  inFlight = run;
-  return run;
-}
-async function doCapture(opts) {
-  const wanted = opts.types ?? widgets.all().filter((d) => d.surface === "gl").map((d) => d.type);
-  const defs = wanted.map((t) => widgets.get(t)).filter((d) => d !== void 0 && d.surface === "gl" && d.component !== null && d.component !== void 0).filter((d) => !hasPreviewSnapshot(d.type));
-  if (defs.length === 0) return [];
-  const canvas = document.createElement("canvas");
-  const root = createRoot(canvas);
-  const captured = [];
-  let resolvedEnv;
-  try {
-    for (const def of defs) {
-      try {
-        const entity = ensureEntity(def);
-        if (entity === void 0 || sandbox === null) continue;
-        const { w, h } = def.defaultSize;
-        const scale = opts.scale ?? Math.min(2, 512 / Math.max(w, h));
-        const callbacks = /* @__PURE__ */ new Set();
-        root.configure({
-          frameloop: "never",
-          gl: { alpha: true, antialias: true, preserveDrawingBuffer: true },
-          orthographic: true,
-          // The island frustum verbatim (island.tsx / the paint pass): center
-          // origin, Y-up, camera on +Z looking at the content plane; `manual`
-          // pins it against R3F's resize auto-frustum.
-          camera: {
-            left: -w / 2,
-            right: w / 2,
-            top: h / 2,
-            bottom: -h / 2,
-            near: 0.1,
-            far: 2e3,
-            position: [0, 0, 500],
-            manual: true
-          },
-          size: { width: w, height: h, top: 0, left: 0 },
-          dpr: scale
-        });
-        const View = def.component;
-        const store = root.render(
-          createElement3(
-            EngineProvider,
-            { engine: sandbox.ce },
-            createElement3(
-              IslandContext.Provider,
-              { value: { bridge: stubBridge(callbacks), entity } },
-              createElement3(View, { entity, world: sandbox.ce.world })
-            )
-          )
-        );
-        if (resolvedEnv === void 0) {
-          resolvedEnv = typeof opts.environment === "function" ? opts.environment(store.getState().gl) : opts.environment ?? null;
-        }
-        store.getState().scene.environment = resolvedEnv;
-        const cam = store.getState().camera;
-        cam.left = -w / 2;
-        cam.right = w / 2;
-        cam.top = h / 2;
-        cam.bottom = -h / 2;
-        cam.near = 0.1;
-        cam.far = 2e3;
-        cam.position.set(0, 0, 500);
-        cam.lookAt(0, 0, 0);
-        cam.updateProjectionMatrix();
-        cam.updateMatrixWorld(true);
-        await sleep(30);
-        const frames = opts.settleFrames ?? 12;
-        for (let i = 0; i < frames; i++) {
-          for (const cb of callbacks) cb(16.7);
-          advance(i * 16.7 / 1e3, false, store.getState());
-          await sleep(16);
-        }
-        for (const cb of callbacks) cb(16.7);
-        advance(frames * 16.7 / 1e3, false, store.getState());
-        const snap = document.createElement("canvas");
-        snap.width = canvas.width;
-        snap.height = canvas.height;
-        snap.getContext("2d")?.drawImage(canvas, 0, 0);
-        setPreviewSnapshot(def.type, snap);
-        captured.push(def.type);
-      } catch (err) {
-        console.warn(`ice: preview capture failed for "${def.type}" \u2014 its tile keeps the fallback.`, err);
-      }
-      await new Promise((r) => {
-        const w = window;
-        if (w.requestIdleCallback !== void 0) w.requestIdleCallback(() => r(), { timeout: 500 });
-        else setTimeout(r, 50);
-      });
-    }
-  } finally {
-    root.unmount();
-  }
-  return captured;
-}
-export {
-  CompositeMaterial,
-  GLViews,
-  Island,
-  IslandContext,
-  RenderTargetPool,
-  ResourceRegistry,
-  captureWidgetPreviews,
-  createGLBridge,
-  createGLPointerRouter,
-  createIslandStateStore,
-  createRenderWriteTrap,
-  runCompositorPass,
-  useIslandContext,
-  useIslandFrame,
-  useIslandInvalidate,
-  useIslandLift,
-  useIslandOpacity
-};
-//# sourceMappingURL=r3f.js.map