@vibecook/ice 0.11.0 → 0.14.0

package/dist/ground.js

@@ -1,1108 +0,0 @@
-import {
-  Active,
-  Camera,
-  Culled,
-  CursorVisual,
-  DEFAULT_GRID_CONFIG,
-  DEFAULT_GRID_MAGNET_CONFIG,
-  DEFAULT_SNAP_GUIDES_CONFIG,
-  DEFAULT_WIRES_CONFIG,
-  Drag,
-  GuideLine,
-  LocalPointer,
-  MeasuredSize,
-  Pointer,
-  PointerWorld,
-  Port,
-  PortAnchor,
-  Position,
-  PrefabId,
-  RoutedConnect,
-  Selected,
-  Size,
-  SpacingBar,
-  SpatialVersion,
-  Wire,
-  WireFrom,
-  WirePorts,
-  WireTo,
-  defineQuery,
-  portSlots,
-  widgets
-} from "./chunk-VGVDJZSP.js";
-import {
-  portAnchor,
-  tessellateCubic,
-  wireCubic,
-  worldToScreen
-} from "./chunk-OR5FNVUE.js";
-
-// ../ground/src/layer.ts
-import { OrthographicCamera, Scene } from "three/webgpu";
-function createLayer(host, world, renderer, passes) {
-  const doc = host.container.ownerDocument;
-  const canvas = renderer.canvas;
-  canvas.style.position = "absolute";
-  canvas.style.left = "0";
-  canvas.style.top = "0";
-  canvas.style.width = "100%";
-  canvas.style.height = "100%";
-  canvas.style.display = "block";
-  canvas.style.pointerEvents = "none";
-  host.container.insertBefore(canvas, host.contentPlane);
-  const scene = new Scene();
-  const camera = new OrthographicCamera(0, 1, 0, 1, -1e3, 1e3);
-  for (const pass of passes) scene.add(pass.object);
-  const dirty = /* @__PURE__ */ new Map();
-  for (const pass of passes) dirty.set(pass, true);
-  let anyDirty = true;
-  const wakeAll = () => {
-    for (const pass of passes) dirty.set(pass, true);
-    anyDirty = true;
-  };
-  const unsubs = [
-    // Camera moves re-map every pass's screen-space geometry (2D-canvas parity).
-    world.reactive.observeResource(Camera, wakeAll)
-  ];
-  for (const pass of passes) {
-    unsubs.push(
-      ...pass.arm(world, () => {
-        dirty.set(pass, true);
-        anyDirty = true;
-      })
-    );
-  }
-  renderer.onReady(wakeAll);
-  let cssW = 0;
-  let cssH = 0;
-  let dpr = 1;
-  const applySize = (w, h) => {
-    dpr = doc.defaultView?.devicePixelRatio ?? 1;
-    cssW = w;
-    cssH = h;
-    renderer.setSize(w, h, dpr);
-    camera.left = 0;
-    camera.right = Math.max(1, w);
-    camera.top = 0;
-    camera.bottom = Math.max(1, h);
-    camera.updateProjectionMatrix();
-    wakeAll();
-  };
-  const initialRect = host.container.getBoundingClientRect();
-  applySize(initialRect.width, initialRect.height);
-  let ro = null;
-  try {
-    ro = new ResizeObserver((entries) => {
-      const entry = entries[0];
-      if (entry === void 0) return;
-      applySize(entry.contentRect.width, entry.contentRect.height);
-    });
-    ro.observe(host.container);
-  } catch {
-    ro = null;
-  }
-  let redraws = 0;
-  const reflector = {
-    name: "ground",
-    // Self-gated on the dirty union (wires/chrome precedent) — the every-frame
-    // cost is one boolean check.
-    always: true,
-    flush(w) {
-      if (!anyDirty || renderer.failed()) return;
-      if (!renderer.ready()) return;
-      const cam = w.getResource(Camera);
-      if (cam === void 0) return;
-      anyDirty = false;
-      const frame = { width: cssW, height: cssH, dpr, camera: cam };
-      for (const pass of passes) {
-        if (dirty.get(pass) === true) {
-          dirty.set(pass, false);
-          pass.collect(w, frame);
-        }
-      }
-      redraws++;
-      renderer.render(scene, camera);
-    },
-    available: () => renderer.ready() && !renderer.failed(),
-    redraws: () => redraws
-  };
-  return {
-    reflector,
-    invalidateAll: wakeAll,
-    dispose() {
-      for (const u of unsubs) u();
-      unsubs.length = 0;
-      ro?.disconnect();
-      ro = null;
-      for (const pass of passes) pass.dispose();
-      renderer.dispose();
-      canvas.remove();
-    }
-  };
-}
-
-// ../ground/src/passes/grid-contract.ts
-function mergeGridConfig(base, next) {
-  const merged = { ...base, ...next };
-  if (next.magnet !== void 0) merged.magnet = { ...base.magnet, ...next.magnet };
-  return merged;
-}
-function resolveInitialGridConfig(initial) {
-  return mergeGridConfig(DEFAULT_GRID_CONFIG, initial);
-}
-
-// ../ground/src/passes/grid-magnet.ts
-import {
-  Fn,
-  If,
-  Loop,
-  abs,
-  clamp,
-  float,
-  instanceIndex,
-  int,
-  length,
-  max,
-  min,
-  mix,
-  mod,
-  positionGeometry,
-  select,
-  sign,
-  smoothstep,
-  sqrt,
-  storage,
-  uniform,
-  varying,
-  vec2,
-  vec4,
-  Continue,
-  Discard
-} from "three/tsl";
-import {
-  BufferAttribute,
-  Group,
-  InstancedBufferGeometry,
-  Mesh,
-  MeshBasicNodeMaterial,
-  StorageBufferAttribute,
-  Vector2,
-  Vector3
-} from "three/webgpu";
-
-// ../ground/src/passes/soup-collect.ts
-var SoupBuilder = class {
-  pos = [];
-  col = [];
-  vert(x, y, c) {
-    this.pos.push(x, y, 0);
-    this.col.push(c[0], c[1], c[2], c[3]);
-  }
-  /** Axis-aligned rect (two triangles). */
-  rect(x, y, w, h, c) {
-    this.vert(x, y, c);
-    this.vert(x + w, y, c);
-    this.vert(x + w, y + h, c);
-    this.vert(x, y, c);
-    this.vert(x + w, y + h, c);
-    this.vert(x, y + h, c);
-  }
-  /** Stroke segment (a→b) of `width`, flat caps — a quad across the segment normal. */
-  segment(ax, ay, bx, by, width, c) {
-    const dx = bx - ax;
-    const dy = by - ay;
-    const len = Math.hypot(dx, dy);
-    if (len < 1e-6) return;
-    const nx = -dy / len * (width / 2);
-    const ny = dx / len * (width / 2);
-    this.vert(ax + nx, ay + ny, c);
-    this.vert(bx + nx, by + ny, c);
-    this.vert(bx - nx, by - ny, c);
-    this.vert(ax + nx, ay + ny, c);
-    this.vert(bx - nx, by - ny, c);
-    this.vert(ax - nx, ay - ny, c);
-  }
-  /** Stroke a polyline (interleaved xy) as per-segment quads (smooth-curve joins). */
-  polyline(points, width, c) {
-    const n = Math.floor(points.length / 2);
-    for (let i = 1; i < n; i++) {
-      this.segment(
-        points[(i - 1) * 2],
-        points[(i - 1) * 2 + 1],
-        points[i * 2],
-        points[i * 2 + 1],
-        width,
-        c
-      );
-    }
-  }
-  /** Filled disc as a triangle fan (MSAA smooths the rim; 16 segs ≈ round at ≤8 px). */
-  disc(cx, cy, r, c, segments = 16) {
-    for (let i = 0; i < segments; i++) {
-      const a0 = i / segments * Math.PI * 2;
-      const a1 = (i + 1) / segments * Math.PI * 2;
-      this.vert(cx, cy, c);
-      this.vert(cx + Math.cos(a0) * r, cy + Math.sin(a0) * r, c);
-      this.vert(cx + Math.cos(a1) * r, cy + Math.sin(a1) * r, c);
-    }
-  }
-  build() {
-    return {
-      positions: new Float32Array(this.pos),
-      colors: new Float32Array(this.col),
-      vertexCount: this.pos.length / 3
-    };
-  }
-};
-function parseCssColor(css) {
-  const rgba = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)$/.exec(css);
-  if (rgba !== null) {
-    return [
-      Number(rgba[1]) / 255,
-      Number(rgba[2]) / 255,
-      Number(rgba[3]) / 255,
-      rgba[4] === void 0 ? 1 : Number(rgba[4])
-    ];
-  }
-  const hex = /^#([0-9a-f]{6})$/i.exec(css);
-  if (hex !== null) {
-    const v = Number.parseInt(hex[1], 16);
-    return [(v >> 16 & 255) / 255, (v >> 8 & 255) / 255, (v & 255) / 255, 1];
-  }
-  return [0.5, 0.5, 0.5, 1];
-}
-
-// ../ground/src/passes/wires-collect.ts
-var wireQ = defineQuery([Wire]);
-var geometryQ = defineQuery([Position, Size]);
-var measuredQ = defineQuery([MeasuredSize]);
-var selectedQ = defineQuery([Selected]);
-var portQ = defineQuery([Port, PortAnchor]);
-var routedConnectQ = defineQuery([RoutedConnect]);
-var connectDragQ = defineQuery([RoutedConnect, Drag]);
-var activeQ = defineQuery([Active]);
-function outOfScope(world, e) {
-  return world.hasTag(e, Culled) && !world.hasTag(e, Active);
-}
-var TESSELLATION_TOLERANCE_PX = 0.25;
-var DASH_PX = 6;
-var GAP_PX = 4;
-function readWidgetRect(world, e) {
-  const p = world.get(e, Position);
-  if (p === void 0) return void 0;
-  const measured = world.get(e, MeasuredSize);
-  const s = measured !== void 0 && measured.w > 0 ? measured : world.get(e, Size);
-  if (s === void 0) return void 0;
-  return { x: p.x, y: p.y, width: s.w, height: s.h };
-}
-var slotCache = /* @__PURE__ */ new Map();
-function slotOf(wt, portId) {
-  let slots = slotCache.get(wt.type);
-  if (slots === void 0) {
-    slots = portSlots(wt.ports);
-    slotCache.set(wt.type, slots);
-  }
-  return slots.get(portId);
-}
-function endpointAnchor(world, widget, portId) {
-  if (widget === void 0) return void 0;
-  const rect = readWidgetRect(world, widget);
-  if (rect === void 0) return void 0;
-  const type = world.get(widget, PrefabId)?.id;
-  if (typeof type !== "string") return void 0;
-  const wt = widgets.get(type);
-  if (wt === void 0) return void 0;
-  const slot = slotOf(wt, portId);
-  if (slot === void 0) return void 0;
-  return { anchor: rect, slot };
-}
-function cubicToScreen(c, cam) {
-  const p0 = worldToScreen(c.x0, c.y0, cam);
-  const p1 = worldToScreen(c.x1, c.y1, cam);
-  const p2 = worldToScreen(c.x2, c.y2, cam);
-  const p3 = worldToScreen(c.x3, c.y3, cam);
-  return { x0: p0.x, y0: p0.y, x1: p1.x, y1: p1.y, x2: p2.x, y2: p2.y, x3: p3.x, y3: p3.y };
-}
-function pointAtLength(t, d) {
-  const arc = t.arcLength;
-  const n = arc.length;
-  let lo = 0;
-  let hi = n - 1;
-  while (lo < hi) {
-    const mid = lo + hi >> 1;
-    if (arc[mid] < d) lo = mid + 1;
-    else hi = mid;
-  }
-  const i = Math.max(1, lo);
-  const a = arc[i - 1];
-  const b = arc[i];
-  const f = b > a ? (d - a) / (b - a) : 0;
-  const x0 = t.points[(i - 1) * 2];
-  const y0 = t.points[(i - 1) * 2 + 1];
-  const x1 = t.points[i * 2];
-  const y1 = t.points[i * 2 + 1];
-  return { x: x0 + (x1 - x0) * f, y: y0 + (y1 - y0) * f };
-}
-function dashedStroke(soup, t, width, c) {
-  const total = t.arcLength[t.arcLength.length - 1];
-  for (let d = 0; d < total; d += DASH_PX + GAP_PX) {
-    const a = pointAtLength(t, d);
-    const b = pointAtLength(t, Math.min(d + DASH_PX, total));
-    soup.segment(a.x, a.y, b.x, b.y, width, c);
-  }
-}
-function collectWires(world, frame, config = DEFAULT_WIRES_CONFIG, preview) {
-  const soup = new SoupBuilder();
-  const cam = frame.camera;
-  const wireColor = parseCssColor(config.wireColor);
-  const selectedColor = parseCssColor(config.selectedColor);
-  world.query(wireQ).each((batch) => {
-    for (const r of batch) {
-      const wire = batch.entity(r);
-      const ports = world.get(wire, WirePorts);
-      if (ports === void 0) continue;
-      const fromWidget = world.getRelation(wire, WireFrom);
-      const toWidget = world.getRelation(wire, WireTo);
-      if (fromWidget !== void 0 && outOfScope(world, fromWidget)) continue;
-      if (toWidget !== void 0 && outOfScope(world, toWidget)) continue;
-      const from = endpointAnchor(world, fromWidget, ports.from ?? "");
-      const to = endpointAnchor(world, toWidget, ports.to ?? "");
-      if (from === void 0 || to === void 0) continue;
-      const cubic = wireCubic(
-        portAnchor(from.anchor, from.slot),
-        from.slot.side,
-        portAnchor(to.anchor, to.slot),
-        to.slot.side
-      );
-      const selected = world.hasTag(wire, Selected);
-      const t = tessellateCubic(cubicToScreen(cubic, cam), TESSELLATION_TOLERANCE_PX);
-      soup.polyline(t.points, selected ? config.selectedWidth : config.wireWidth, selected ? selectedColor : wireColor);
-    }
-  });
-  if (preview?.active === true) {
-    const stub = Math.max(24, Math.abs(preview.tx - preview.sx) * 0.5);
-    const cubic = {
-      x0: preview.sx,
-      y0: preview.sy,
-      x1: preview.sx + stub,
-      y1: preview.sy,
-      x2: preview.tx - stub,
-      y2: preview.ty,
-      x3: preview.tx,
-      y3: preview.ty
-    };
-    const t = tessellateCubic(cubicToScreen(cubic, cam), TESSELLATION_TOLERANCE_PX);
-    if (preview.compatible) soup.polyline(t.points, config.wireWidth, selectedColor);
-    else dashedStroke(soup, t, config.wireWidth, wireColor);
-  }
-  const connecting = world.firstOf(routedConnectQ) !== void 0;
-  const dotColor = parseCssColor(connecting ? config.portActiveColor : config.portColor);
-  world.query(portQ).each((batch) => {
-    const ax = batch.col(PortAnchor).x;
-    const ay = batch.col(PortAnchor).y;
-    for (const r of batch) {
-      const s = worldToScreen(ax[r], ay[r], cam);
-      soup.disc(s.x, s.y, config.portRadius, dotColor);
-    }
-  });
-  return soup.build();
-}
-
-// ../ground/src/passes/magnet-collect.ts
-var MAGNET_SOURCE_FLOATS = 8;
-var MAX_MAGNET_SOURCES = 256;
-var MAX_MAGNET_INSTANCES = 22e4;
-function resolveMagnet(cfg) {
-  return { ...DEFAULT_GRID_MAGNET_CONFIG, ...cfg.magnet };
-}
-function fadeOpacity(cssSpacing, fadeIn, fadeOut) {
-  const rise = (cssSpacing - fadeIn[0]) / Math.max(fadeIn[1] - fadeIn[0], 1e-4);
-  const fall = 1 - (cssSpacing - fadeOut[0]) / Math.max(fadeOut[1] - fadeOut[0], 1e-4);
-  return Math.min(Math.max(Math.min(rise, fall), 0), 1);
-}
-function magnetFieldScale(zoom, fadeZoom) {
-  if (fadeZoom <= 0) return 1;
-  const t = (zoom - 0.7 * fadeZoom) / (0.3 * fadeZoom);
-  return Math.min(Math.max(t, 0), 1);
-}
-function collectMagnetLevels(frame, cfg) {
-  const { camera } = frame;
-  const out = [];
-  const opacities = cfg.spacings.map((s) => fadeOpacity(s * camera.zoom, cfg.fadeIn, cfg.fadeOut));
-  for (let i = 0; i < cfg.spacings.length; i++) {
-    const spacing = cfg.spacings[i];
-    const opacity = opacities[i];
-    const weight = cfg.levelWeight[0] + i * cfg.levelWeight[1];
-    const alpha = opacity * weight * cfg.dotAlpha;
-    if (opacity < 0.01 || alpha <= 0) {
-      out.push({ i0: 0, j0: 0, cols: 0, rows: 0, count: 0, alpha: 0, skipModulo: 0 });
-      continue;
-    }
-    const worldW = frame.width / camera.zoom;
-    const worldH = frame.height / camera.zoom;
-    const i0 = Math.floor(camera.x / spacing) - 1;
-    const j0 = Math.floor(camera.y / spacing) - 1;
-    const i1 = Math.ceil((camera.x + worldW) / spacing) + 1;
-    const j1 = Math.ceil((camera.y + worldH) / spacing) + 1;
-    const cols = Math.max(1, i1 - i0);
-    const rows = Math.max(1, j1 - j0);
-    const count = cols * rows;
-    if (count > MAX_MAGNET_INSTANCES) {
-      out.push({ i0: 0, j0: 0, cols: 0, rows: 0, count: 0, alpha: 0, skipModulo: 0 });
-      continue;
-    }
-    let skipModulo = 0;
-    const next = cfg.spacings[i + 1];
-    if (next !== void 0 && opacities[i + 1] >= 0.01) {
-      const ratio = next / spacing;
-      if (Number.isInteger(ratio) && ratio > 1) skipModulo = ratio;
-    }
-    out.push({ i0, j0, cols, rows, count, alpha, skipModulo });
-  }
-  return out;
-}
-function collectMagnetSources(world, frame, magnet, fieldScale, poles, readSpatial, out) {
-  if (fieldScale <= 0) return 0;
-  const { camera } = frame;
-  const cap = Math.min(magnet.maxSources, MAX_MAGNET_SOURCES, Math.floor(out.length / MAGNET_SOURCE_FLOATS));
-  let n = 0;
-  for (const pole of poles) {
-    if (n >= cap) break;
-    if (!(pole.strength > 0)) continue;
-    const s = pole.space === "screen" ? pole : worldToScreen(pole.x, pole.y, camera);
-    const o = n * MAGNET_SOURCE_FLOATS;
-    out[o + 0] = s.x;
-    out[o + 1] = s.y;
-    out[o + 2] = 0;
-    out[o + 3] = 0;
-    out[o + 4] = 0;
-    out[o + 5] = pole.strength * fieldScale;
-    out[o + 6] = 0;
-    out[o + 7] = 0;
-    n++;
-  }
-  if (!magnet.widgets || readSpatial === void 0 || magnet.widgetStrength <= 0 || n >= cap) {
-    return n;
-  }
-  const haloCss = 5 * magnet.reach * Math.sqrt(Math.max(magnet.widgetStrength * fieldScale, 1e-4));
-  const pad = haloCss / camera.zoom;
-  const hits = readSpatial({
-    minX: camera.x - pad,
-    minY: camera.y - pad,
-    maxX: camera.x + frame.width / camera.zoom + pad,
-    maxY: camera.y + frame.height / camera.zoom + pad
-  });
-  const viewCx = frame.width / 2;
-  const viewCy = frame.height / 2;
-  const candidates = [];
-  for (const hit of hits) {
-    const rect = readWidgetRect(world, hit.id);
-    if (rect === void 0 || rect.width <= 0 || rect.height <= 0) continue;
-    const hx = rect.width / 2 * camera.zoom;
-    const hy = rect.height / 2 * camera.zoom;
-    const center = worldToScreen(rect.x + rect.width / 2, rect.y + rect.height / 2, camera);
-    candidates.push({
-      cx: center.x,
-      cy: center.y,
-      hx,
-      hy,
-      r: Math.min(magnet.widgetRadius * camera.zoom, hx, hy),
-      area: hx * hy,
-      centerDist: (center.x - viewCx) ** 2 + (center.y - viewCy) ** 2
-    });
-  }
-  const budget = cap - n;
-  if (candidates.length > budget) {
-    candidates.sort((a, b) => b.area - a.area || a.centerDist - b.centerDist);
-    candidates.length = budget;
-  }
-  const strength = magnet.widgetStrength * fieldScale;
-  for (const c of candidates) {
-    const o = n * MAGNET_SOURCE_FLOATS;
-    out[o + 0] = c.cx;
-    out[o + 1] = c.cy;
-    out[o + 2] = c.hx;
-    out[o + 3] = c.hy;
-    out[o + 4] = c.r;
-    out[o + 5] = strength;
-    out[o + 6] = 0;
-    out[o + 7] = 0;
-    n++;
-  }
-  return n;
-}
-
-// ../ground/src/passes/grid-magnet.ts
-var CORNERS = new Float32Array([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, -1, 0, 1, 1, 0, -1, 1, 0]);
-var LEVELS = 3;
-function createMagnetGrid() {
-  const sourceArray = new Float32Array(MAX_MAGNET_SOURCES * MAGNET_SOURCE_FLOATS);
-  const sourceAttr = new StorageBufferAttribute(sourceArray, 4);
-  const sourceBuf = storage(sourceAttr, "vec4", MAX_MAGNET_SOURCES * 2).setPBO(true).toReadOnly();
-  const uCam = uniform(new Vector2(0, 0));
-  const uZoom = uniform(1);
-  const uView = uniform(new Vector2(1, 1));
-  const uDotMode = uniform(0);
-  const uHalfLen = uniform(5);
-  const uHalfWidth = uniform(0.55);
-  const uRestRadius = uniform(0.75);
-  const uK = uniform(0);
-  const uPad = uniform(0);
-  const uPolarity = uniform(1);
-  const uAlwaysAlign = uniform(0);
-  const uCount = uniform(0, "int");
-  const uColor = uniform(new Vector3(0.75, 0.77, 0.8));
-  const EPS = float(25);
-  const REST = vec2(0, 1);
-  const sdRoundBox = Fn(([p, b, r]) => {
-    const q = abs(p).sub(b).add(vec2(r, r));
-    return length(max(q, vec2(0, 0))).add(min(max(q.x, q.y), 0)).sub(r);
-  });
-  const roundBoxNormal = Fn(([p, b, r]) => {
-    const s = sign(p);
-    const q = abs(p);
-    const inner = max(b.sub(vec2(r, r)), vec2(0, 0));
-    const d = q.sub(inner);
-    const n = vec2(0, 0).toVar();
-    If(d.x.greaterThan(0).and(d.y.greaterThan(0)), () => {
-      const len = length(d);
-      If(len.greaterThan(1e-4), () => {
-        n.assign(s.mul(d.div(len)));
-      }).Else(() => {
-        n.assign(vec2(s.x, 0));
-      });
-    }).ElseIf(d.x.greaterThan(d.y), () => {
-      n.assign(vec2(s.x, 0));
-    }).Else(() => {
-      n.assign(vec2(0, s.y));
-    });
-    return n;
-  });
-  const safeNormalize = Fn(([v, fallback]) => {
-    const n = length(v);
-    return select(n.greaterThan(1e-4), v.div(max(n, 1e-4)), fallback);
-  });
-  const group = new Group();
-  const geometries = [];
-  const materials = [];
-  const meshes = [];
-  const levelUniforms = Array.from({ length: LEVELS }, () => ({
-    origin: uniform(new Vector2(0, 0)),
-    dims: uniform(new Vector2(1, 1)),
-    spacing: uniform(20),
-    alpha: uniform(0),
-    skipMod: uniform(0)
-  }));
-  for (let level = 0; level < LEVELS; level++) {
-    const lu = levelUniforms[level];
-    const vUv = varying(vec2(0, 0), `vMagnetUv${level}`);
-    const vAlpha = varying(float(0), `vMagnetAlpha${level}`);
-    const vertexNode = Fn(() => {
-      const iid = float(instanceIndex);
-      const cols = lu.dims.x;
-      const col = mod(iid, cols).floor().toVar();
-      const row = iid.div(cols).floor().toVar();
-      const world = lu.origin.add(vec2(col, row)).mul(lu.spacing);
-      const screen = world.sub(uCam).mul(uZoom).toVar();
-      const field = vec2(0, 0).toVar();
-      const minD = float(1e9).toVar();
-      Loop({ start: int(0), end: uCount, type: "int", condition: "<" }, ({ i }) => {
-        const a = sourceBuf.element(i.mul(2));
-        const b = sourceBuf.element(i.mul(2).add(1));
-        const center = a.xy;
-        const half = a.zw;
-        const rad = b.x;
-        const strength = b.y;
-        const rel = screen.sub(center);
-        const reach = uPad.mul(sqrt(max(strength, 1e-4)));
-        If(
-          abs(rel.x).greaterThan(half.x.add(reach)).or(abs(rel.y).greaterThan(half.y.add(reach))),
-          () => {
-            Continue();
-          }
-        );
-        const d = sdRoundBox(rel, half, rad);
-        minD.assign(min(minD, d));
-        const dist = max(d, 0);
-        const r2 = dist.mul(dist).add(EPS);
-        const outward = roundBoxNormal(rel, half, rad);
-        field.subAssign(outward.mul(uK.mul(strength).mul(uPolarity).div(r2)));
-      });
-      const fieldDir = safeNormalize(field, REST);
-      const mag = length(field);
-      const influence = select(uDotMode.greaterThan(0.5), mag.div(mag.add(1)), clamp(mag, 0, 1));
-      const corner = positionGeometry.xy;
-      const dotRadius = mix(uRestRadius, uHalfLen.mul(1.05), influence);
-      const dotLocal = vec2(corner.x, corner.y.negate()).mul(dotRadius);
-      const dir = select(
-        uAlwaysAlign.greaterThan(0.5),
-        fieldDir,
-        safeNormalize(mix(REST, fieldDir, influence), REST)
-      );
-      const nrm = vec2(dir.y.negate(), dir.x);
-      const nLen = mix(uHalfLen.mul(0.55), uHalfLen.mul(1.35), influence);
-      const nWid = mix(uHalfWidth.mul(0.85), uHalfWidth.mul(1.15), influence);
-      const needleLocal = nrm.mul(corner.x).mul(nWid).add(dir.mul(corner.y).mul(nLen));
-      const local = select(uDotMode.greaterThan(0.5), dotLocal, needleLocal);
-      const pos = screen.add(local);
-      const restAlpha = select(uDotMode.greaterThan(0.5), float(0.72), float(0.35));
-      const fieldAlpha = mix(restAlpha, float(1), influence);
-      const alpha = clamp(lu.alpha.mul(fieldAlpha), 0, 1).toVar();
-      If(minD.lessThan(-0.5), () => {
-        alpha.assign(0);
-      });
-      const absI = lu.origin.x.add(col);
-      const absJ = lu.origin.y.add(row);
-      If(
-        lu.skipMod.greaterThan(0.5).and(mod(absI, lu.skipMod).lessThan(0.5)).and(mod(absJ, lu.skipMod).lessThan(0.5)),
-        () => {
-          alpha.assign(0);
-        }
-      );
-      vUv.assign(corner);
-      vAlpha.assign(alpha);
-      const ndc = vec2(
-        pos.x.div(uView.x).mul(2).sub(1),
-        float(1).sub(pos.y.div(uView.y).mul(2))
-      );
-      return vec4(ndc, 0, 1);
-    })();
-    const fragmentNode = Fn(() => {
-      const dotEdge = float(1).sub(smoothstep(0.62, 1, length(vUv)));
-      const ax = float(1).sub(smoothstep(0.55, 1, abs(vUv.x)));
-      const ay = float(1).sub(smoothstep(0.82, 1, abs(vUv.y)));
-      const edge = select(uDotMode.greaterThan(0.5), dotEdge, ax.mul(ay));
-      const a = vAlpha.mul(edge);
-      Discard(a.lessThan(0.01));
-      return vec4(uColor, a);
-    })();
-    const material = new MeshBasicNodeMaterial();
-    material.vertexNode = vertexNode;
-    material.fragmentNode = fragmentNode;
-    material.transparent = true;
-    material.depthTest = false;
-    material.depthWrite = false;
-    const geometry = new InstancedBufferGeometry();
-    geometry.setAttribute("position", new BufferAttribute(CORNERS, 3));
-    geometry.instanceCount = 0;
-    const mesh = new Mesh(geometry, material);
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 0;
-    mesh.visible = false;
-    geometries.push(geometry);
-    materials.push(material);
-    meshes.push(mesh);
-    group.add(mesh);
-  }
-  return {
-    group,
-    update(frame, cfg, magnet, levels, sources, sourceCount) {
-      uCam.value.set(frame.camera.x, frame.camera.y);
-      uZoom.value = frame.camera.zoom;
-      uView.value.set(Math.max(1, frame.width), Math.max(1, frame.height));
-      uDotMode.value = magnet.glyph === "dot" ? 1 : 0;
-      uHalfLen.value = magnet.needleLength;
-      uHalfWidth.value = magnet.needleWidth;
-      uRestRadius.value = cfg.dotRadius[0];
-      const k = 0.5 * magnet.reach * magnet.reach;
-      uK.value = k;
-      uPad.value = Math.sqrt(Math.max(k, 1) / 0.02);
-      uPolarity.value = magnet.polarity;
-      uAlwaysAlign.value = magnet.alwaysAlign ? 1 : 0;
-      uCount.value = sourceCount;
-      uColor.value.set(...cfg.dotColor);
-      if (sourceCount > 0) {
-        sourceArray.set(sources.subarray(0, sourceCount * MAGNET_SOURCE_FLOATS));
-        sourceAttr.needsUpdate = true;
-      }
-      for (let level = 0; level < LEVELS; level++) {
-        const win = levels[level];
-        const lu = levelUniforms[level];
-        const geometry = geometries[level];
-        const mesh = meshes[level];
-        if (win === void 0 || win.count <= 0) {
-          geometry.instanceCount = 0;
-          mesh.visible = false;
-          continue;
-        }
-        lu.origin.value.set(win.i0, win.j0);
-        lu.dims.value.set(win.cols, win.rows);
-        lu.spacing.value = cfg.spacings[level];
-        lu.alpha.value = win.alpha;
-        lu.skipMod.value = win.skipModulo;
-        geometry.instanceCount = win.count;
-        mesh.visible = true;
-      }
-    },
-    dispose() {
-      for (const g of geometries) g.dispose();
-      for (const m of materials) m.dispose();
-    }
-  };
-}
-
-// ../ground/src/passes/grid-magnet-pass.ts
-var createGridPass = (initial = {}, deps = {}) => {
-  let cfg = resolveInitialGridConfig(initial);
-  const renderer = createMagnetGrid();
-  const poles = deps.poles ?? [];
-  const sourceScratch = new Float32Array(MAX_MAGNET_SOURCES * MAGNET_SOURCE_FLOATS);
-  const poleScratch = [];
-  return {
-    name: "grid",
-    object: renderer.group,
-    arm(world, wake) {
-      const wakeIfWidgets = () => {
-        const magnet = resolveMagnet(cfg);
-        if (magnet.widgets && deps.readSpatial !== void 0) wake();
-      };
-      const unsubs = [world.reactive.observeResource(SpatialVersion, wakeIfWidgets)];
-      for (const source of poles) unsubs.push(source.subscribe(world, wake));
-      return unsubs;
-    },
-    collect(world, frame) {
-      const magnet = resolveMagnet(cfg);
-      const fieldScale = magnetFieldScale(frame.camera.zoom, magnet.fadeZoom);
-      poleScratch.length = 0;
-      if (fieldScale > 0) {
-        for (const source of poles) poleScratch.push(...source.read(world));
-      }
-      const sourceCount = collectMagnetSources(
-        world,
-        frame,
-        magnet,
-        fieldScale,
-        poleScratch,
-        deps.readSpatial,
-        sourceScratch
-      );
-      const levels = collectMagnetLevels(frame, cfg);
-      renderer.update(frame, cfg, magnet, levels, sourceScratch, sourceCount);
-    },
-    configure(next) {
-      cfg = mergeGridConfig(cfg, next);
-    },
-    dispose() {
-      renderer.dispose();
-    }
-  };
-};
-
-// ../ground/src/passes/guides-collect.ts
-var guideQ = defineQuery([GuideLine]);
-var barQ = defineQuery([SpacingBar]);
-function collectGuides(world, frame, config = DEFAULT_SNAP_GUIDES_CONFIG) {
-  const soup = new SoupBuilder();
-  const cam = frame.camera;
-  const lw = config.lineWidth;
-  const guideColor = [config.color[0], config.color[1], config.color[2], config.guideAlpha];
-  const barColor = [config.color[0], config.color[1], config.color[2], config.spacingAlpha];
-  world.query(guideQ).each((b) => {
-    for (const r of b) {
-      const g = world.read(b.entity(r), GuideLine);
-      const fullSpan = g.from === g.to;
-      if (g.axis === "x") {
-        const sx = worldToScreen(g.at, 0, cam).x;
-        if (frame.width > 0 && (sx < -1 || sx > frame.width + 1)) continue;
-        const y0 = fullSpan ? 0 : worldToScreen(0, g.from, cam).y;
-        const y1 = fullSpan ? frame.height : worldToScreen(0, g.to, cam).y;
-        soup.rect(sx - lw / 2, Math.min(y0, y1), lw, Math.abs(y1 - y0), guideColor);
-      } else {
-        const sy = worldToScreen(0, g.at, cam).y;
-        if (frame.height > 0 && (sy < -1 || sy > frame.height + 1)) continue;
-        const x0 = fullSpan ? 0 : worldToScreen(g.from, 0, cam).x;
-        const x1 = fullSpan ? frame.width : worldToScreen(g.to, 0, cam).x;
-        soup.rect(Math.min(x0, x1), sy - lw / 2, Math.abs(x1 - x0), lw, guideColor);
-      }
-    }
-  });
-  world.query(barQ).each((b) => {
-    for (const r of b) {
-      const s = world.read(b.entity(r), SpacingBar);
-      const t = config.tickPx;
-      if (s.axis === "x") {
-        const a = worldToScreen(s.from, s.perp, cam);
-        const bp = worldToScreen(s.to, s.perp, cam);
-        if (frame.width > 0 && (Math.max(a.x, bp.x) < 0 || Math.min(a.x, bp.x) > frame.width)) continue;
-        soup.rect(Math.min(a.x, bp.x), a.y - lw / 2, Math.abs(bp.x - a.x), lw, barColor);
-        soup.rect(a.x - lw / 2, a.y - t, lw, t * 2, barColor);
-        soup.rect(bp.x - lw / 2, bp.y - t, lw, t * 2, barColor);
-      } else {
-        const a = worldToScreen(s.perp, s.from, cam);
-        const bp = worldToScreen(s.perp, s.to, cam);
-        if (frame.height > 0 && (Math.max(a.y, bp.y) < 0 || Math.min(a.y, bp.y) > frame.height)) continue;
-        soup.rect(a.x - lw / 2, Math.min(a.y, bp.y), lw, Math.abs(bp.y - a.y), barColor);
-        soup.rect(a.x - t, a.y - lw / 2, t * 2, lw, barColor);
-        soup.rect(bp.x - t, bp.y - lw / 2, t * 2, lw, barColor);
-      }
-    }
-  });
-  return soup.build();
-}
-
-// ../ground/src/passes/soup-mesh.ts
-import { attribute } from "three/tsl";
-import { BufferAttribute as BufferAttribute2, BufferGeometry, DoubleSide, Mesh as Mesh2, MeshBasicNodeMaterial as MeshBasicNodeMaterial2 } from "three/webgpu";
-function createSoupMesh(renderOrder) {
-  const material = new MeshBasicNodeMaterial2();
-  material.fragmentNode = attribute("color", "vec4");
-  material.transparent = true;
-  material.depthTest = false;
-  material.depthWrite = false;
-  material.side = DoubleSide;
-  let geometry = new BufferGeometry();
-  let capacity = 0;
-  const mesh = new Mesh2(geometry, material);
-  mesh.frustumCulled = false;
-  mesh.renderOrder = renderOrder;
-  mesh.visible = false;
-  return {
-    mesh,
-    update(soup) {
-      if (soup.vertexCount === 0) {
-        mesh.visible = false;
-        geometry.setDrawRange(0, 0);
-        return;
-      }
-      if (soup.vertexCount > capacity) {
-        capacity = Math.max(soup.vertexCount, capacity * 2, 256);
-        const old = geometry;
-        geometry = new BufferGeometry();
-        const pos = new Float32Array(capacity * 3);
-        const col = new Float32Array(capacity * 4);
-        pos.set(soup.positions);
-        col.set(soup.colors);
-        geometry.setAttribute("position", new BufferAttribute2(pos, 3));
-        geometry.setAttribute("color", new BufferAttribute2(col, 4));
-        mesh.geometry = geometry;
-        old.dispose();
-      } else {
-        const pos = geometry.getAttribute("position");
-        const col = geometry.getAttribute("color");
-        pos.array.set(soup.positions);
-        col.array.set(soup.colors);
-        pos.needsUpdate = true;
-        col.needsUpdate = true;
-      }
-      geometry.setDrawRange(0, soup.vertexCount);
-      mesh.visible = true;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-
-// ../ground/src/passes/guides.ts
-function createGuidesPass(initial = {}) {
-  const config = { ...DEFAULT_SNAP_GUIDES_CONFIG, ...initial };
-  const soup = createSoupMesh(2);
-  return {
-    name: "snap-guides",
-    object: soup.mesh,
-    arm(world, wake) {
-      return [
-        world.reactive.observeQuery(guideQ, wake, { cols: [GuideLine] }),
-        world.reactive.observeQuery(barQ, wake, { cols: [SpacingBar] })
-      ];
-    },
-    collect(world, frame) {
-      soup.update(collectGuides(world, frame, config));
-    },
-    dispose() {
-      soup.dispose();
-    }
-  };
-}
-
-// ../ground/src/passes/wires.ts
-function createWiresPass(initial = {}, readPreview) {
-  const config = { ...DEFAULT_WIRES_CONFIG, ...initial };
-  const soup = createSoupMesh(1);
-  return {
-    name: "wires",
-    object: soup.mesh,
-    arm(world, wake) {
-      return [
-        world.reactive.observeQuery(wireQ, wake, { cols: [] }),
-        world.reactive.observeQuery(geometryQ, wake, { cols: [Position, Size] }),
-        // MeasuredSize rides its own observer (readRect prefers it over Size):
-        // in geometryQ's cols it would REQUIRE the rider and drop plain widgets.
-        world.reactive.observeQuery(measuredQ, wake, { cols: [MeasuredSize] }),
-        world.reactive.observeQuery(selectedQ, wake, { cols: [] }),
-        // Nav churn: Active membership flips gate the scope filter (a wire
-        // whose endpoints left the current frame must disappear this frame).
-        world.reactive.observeQuery(activeQ, wake, { cols: [] }),
-        world.reactive.observeQuery(portQ, wake, { cols: [PortAnchor] }),
-        world.reactive.observeQuery(routedConnectQ, wake, { cols: [] }),
-        world.reactive.observeQuery(connectDragQ, wake, { cols: [Drag] })
-      ];
-    },
-    collect(world, frame) {
-      soup.update(collectWires(world, frame, config, readPreview?.()));
-    },
-    dispose() {
-      soup.dispose();
-    }
-  };
-}
-
-// ../ground/src/renderer.ts
-import { WebGPURenderer } from "three/webgpu";
-function createGroundRenderer(doc, opts = {}) {
-  const canvas = doc.createElement("canvas");
-  let renderer = null;
-  let isReady = false;
-  let isFailed = false;
-  const readyCbs = [];
-  const gpu = globalThis.navigator?.gpu;
-  if (gpu == null || opts.forceWebGL === true) {
-    let gl2 = null;
-    try {
-      gl2 = doc.createElement("canvas").getContext("webgl2");
-    } catch {
-      gl2 = null;
-    }
-    if (gl2 === null) isFailed = true;
-  }
-  if (!isFailed) {
-    try {
-      renderer = new WebGPURenderer({
-        canvas,
-        alpha: true,
-        // transparent clear — the page background shows through P0
-        antialias: true,
-        ...opts.forceWebGL === true ? { forceWebGL: true } : {}
-      });
-      renderer.init().then(() => {
-        isReady = true;
-        for (const cb of readyCbs.splice(0)) cb();
-      }).catch(() => {
-        isFailed = true;
-      });
-    } catch {
-      isFailed = true;
-    }
-  }
-  let lastW = 0;
-  let lastH = 0;
-  let lastDpr = 0;
-  return {
-    canvas,
-    ready: () => isReady,
-    failed: () => isFailed,
-    onReady(cb) {
-      if (isReady) cb();
-      else readyCbs.push(cb);
-    },
-    setSize(cssW, cssH, dpr) {
-      if (renderer === null || cssW === lastW && cssH === lastH && dpr === lastDpr) return;
-      lastW = cssW;
-      lastH = cssH;
-      lastDpr = dpr;
-      try {
-        renderer.setPixelRatio(dpr);
-        renderer.setSize(Math.max(1, cssW), Math.max(1, cssH), false);
-      } catch {
-        isFailed = true;
-      }
-    },
-    render(scene, camera) {
-      if (renderer === null || !isReady || isFailed) return;
-      try {
-        renderer.render(scene, camera);
-      } catch {
-        isFailed = true;
-      }
-    },
-    dispose() {
-      try {
-        renderer?.dispose();
-      } catch {
-      }
-      renderer = null;
-    }
-  };
-}
-
-// ../ground/src/poles.ts
-var localPointerQ = defineQuery([Pointer, PointerWorld, LocalPointer]);
-function localPointerPoles(opts = {}) {
-  const strength = opts.strength ?? 1;
-  return {
-    read(world) {
-      const out = [];
-      world.query(localPointerQ).each((b) => {
-        for (const r of b) {
-          const p = world.read(b.entity(r), PointerWorld);
-          out.push({ x: p.x, y: p.y, strength, space: "world" });
-        }
-      });
-      return out;
-    },
-    subscribe(world, wake) {
-      return world.reactive.observeQuery(localPointerQ, wake, { cols: [PointerWorld] });
-    }
-  };
-}
-var cursorVisualQ = defineQuery([Position, CursorVisual]);
-function cursorVisualPoles(opts = {}) {
-  const strength = opts.strength ?? 1;
-  return {
-    read(world) {
-      const out = [];
-      world.query(cursorVisualQ).each((b) => {
-        for (const r of b) {
-          const p = world.read(b.entity(r), Position);
-          out.push({ x: p.x, y: p.y, strength, space: "world" });
-        }
-      });
-      return out;
-    },
-    subscribe(world, wake) {
-      return world.reactive.observeQuery(cursorVisualQ, wake, { cols: [Position] });
-    }
-  };
-}
-
-// ../ground/src/index.ts
-function ground(opts = {}) {
-  return (ctx) => {
-    const doc = ctx.host.container.ownerDocument;
-    const renderer = opts.rendererOverride ?? createGroundRenderer(doc, { forceWebGL: opts.forceWebGL === true });
-    const poles = opts.poles === void 0 ? [] : Array.isArray(opts.poles) ? opts.poles : [opts.poles];
-    const grid = createGridPass(opts.grid ?? {}, { poles, ...ctx.readSpatial !== void 0 ? { readSpatial: ctx.readSpatial } : {} });
-    const wires = createWiresPass(opts.wires ?? {}, ctx.readWirePreview);
-    const guides = createGuidesPass(opts.guides ?? {});
-    const passes = [grid, wires, guides, ...opts.passes ?? []];
-    const layer = createLayer(ctx.host, ctx.world, renderer, passes);
-    return {
-      reflector: layer.reflector,
-      configureGrid(cfg) {
-        grid.configure(cfg);
-        layer.invalidateAll();
-      },
-      dispose: layer.dispose
-    };
-  };
-}
-export {
-  DEFAULT_GRID_CONFIG,
-  DEFAULT_GRID_MAGNET_CONFIG,
-  DEFAULT_SNAP_GUIDES_CONFIG,
-  DEFAULT_WIRES_CONFIG,
-  MAX_MAGNET_SOURCES,
-  SoupBuilder,
-  collectGuides,
-  collectMagnetLevels,
-  collectMagnetSources,
-  collectWires,
-  cursorVisualPoles,
-  ground,
-  localPointerPoles,
-  magnetFieldScale,
-  parseCssColor,
-  resolveMagnet
-};
-//# sourceMappingURL=ground.js.map