@vibecook/ice 0.8.1 → 0.10.0

package/dist/ground.js

@@ -2,12 +2,17 @@ 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,
@@ -16,6 +21,7 @@ import {
   Selected,
   Size,
   SpacingBar,
+  SpatialVersion,
   Wire,
   WireFrom,
   WirePorts,
@@ -23,7 +29,7 @@ import {
   defineQuery,
   portSlots,
   widgets
-} from "./chunk-VITC7U3J.js";
+} from "./chunk-5FQS7V2C.js";
 import {
   portAnchor,
   tessellateCubic,
@@ -136,6 +142,9 @@ function createLayer(host, world, renderer, passes) {
 }
 
 // ../ground/src/passes/grid.ts
+import { Group as Group2 } from "three/webgpu";
+
+// ../ground/src/passes/grid-classic.ts
 import {
   clamp,
   float,
@@ -159,8 +168,7 @@ import {
   Vector3
 } from "three/webgpu";
 var FULLSCREEN_TRIANGLE = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);
-function createGridPass(initial = {}) {
-  let cfg = { ...DEFAULT_GRID_CONFIG, ...initial };
+function createClassicGrid(cfg) {
   const uCamera = uniform(new Vector2(0, 0));
   const uZoom = uniform(1);
   const uDpr = uniform(1);
@@ -200,24 +208,20 @@ function createGridPass(initial = {}) {
   mesh.frustumCulled = false;
   mesh.renderOrder = 0;
   return {
-    name: "grid",
-    object: mesh,
-    arm: () => [],
-    // camera/resize dirt is layer-owned; config re-tunes call invalidate
-    collect(_world, frame) {
+    mesh,
+    setCamera(frame) {
       uCamera.value.set(frame.camera.x, frame.camera.y);
       uZoom.value = frame.camera.zoom;
       uDpr.value = frame.dpr;
     },
     configure(next) {
-      cfg = { ...cfg, ...next };
-      uSpacings.value.set(...cfg.spacings);
-      uDotColor.value.set(...cfg.dotColor);
-      uDotAlpha.value = cfg.dotAlpha;
-      uFadeIn.value.set(...cfg.fadeIn);
-      uFadeOut.value.set(...cfg.fadeOut);
-      uDotRadius.value.set(...cfg.dotRadius);
-      uLevelWeight.value.set(...cfg.levelWeight);
+      uSpacings.value.set(...next.spacings);
+      uDotColor.value.set(...next.dotColor);
+      uDotAlpha.value = next.dotAlpha;
+      uFadeIn.value.set(...next.fadeIn);
+      uFadeOut.value.set(...next.fadeOut);
+      uDotRadius.value.set(...next.dotRadius);
+      uLevelWeight.value.set(...next.levelWeight);
     },
     dispose() {
       geometry.dispose();
@@ -226,6 +230,45 @@ function createGridPass(initial = {}) {
   };
 }
 
+// ../ground/src/passes/grid-magnet.ts
+import {
+  Fn,
+  If,
+  Loop,
+  abs,
+  clamp as clamp2,
+  float as float2,
+  instanceIndex,
+  int,
+  length as length2,
+  max as max2,
+  min as min2,
+  mix as mix2,
+  mod,
+  positionGeometry as positionGeometry2,
+  select,
+  sign,
+  smoothstep as smoothstep2,
+  sqrt,
+  storage,
+  uniform as uniform2,
+  varying,
+  vec2,
+  vec4 as vec42,
+  Continue,
+  Discard
+} from "three/tsl";
+import {
+  BufferAttribute as BufferAttribute2,
+  Group,
+  InstancedBufferGeometry,
+  Mesh as Mesh2,
+  MeshBasicNodeMaterial as MeshBasicNodeMaterial2,
+  StorageBufferAttribute,
+  Vector2 as Vector22,
+  Vector3 as Vector32
+} from "three/webgpu";
+
 // ../ground/src/passes/soup-collect.ts
 var SoupBuilder = class {
   pos = [];
@@ -308,134 +351,6 @@ function parseCssColor(css) {
   return [0.5, 0.5, 0.5, 1];
 }
 
-// ../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 as BufferGeometry2, 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 BufferGeometry2();
-  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 BufferGeometry2();
-        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-collect.ts
 var wireQ = defineQuery([Wire]);
 var geometryQ = defineQuery([Position, Size]);
@@ -451,7 +366,7 @@ function outOfScope(world, e) {
 var TESSELLATION_TOLERANCE_PX = 0.25;
 var DASH_PX = 6;
 var GAP_PX = 4;
-function readRect(world, e) {
+function readWidgetRect(world, e) {
   const p = world.get(e, Position);
   if (p === void 0) return void 0;
   const measured = world.get(e, MeasuredSize);
@@ -470,7 +385,7 @@ function slotOf(wt, portId) {
 }
 function endpointAnchor(world, widget, portId) {
   if (widget === void 0) return void 0;
-  const rect = readRect(world, widget);
+  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;
@@ -572,6 +487,540 @@ function collectWires(world, frame, config = DEFAULT_WIRES_CONFIG, preview) {
   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 = uniform2(new Vector22(0, 0));
+  const uZoom = uniform2(1);
+  const uView = uniform2(new Vector22(1, 1));
+  const uDotMode = uniform2(0);
+  const uHalfLen = uniform2(5);
+  const uHalfWidth = uniform2(0.55);
+  const uRestRadius = uniform2(0.75);
+  const uK = uniform2(0);
+  const uPad = uniform2(0);
+  const uPolarity = uniform2(1);
+  const uAlwaysAlign = uniform2(0);
+  const uCount = uniform2(0, "int");
+  const uColor = uniform2(new Vector32(0.75, 0.77, 0.8));
+  const EPS = float2(25);
+  const REST = vec2(0, 1);
+  const sdRoundBox = Fn(([p, b, r]) => {
+    const q = abs(p).sub(b).add(vec2(r, r));
+    return length2(max2(q, vec2(0, 0))).add(min2(max2(q.x, q.y), 0)).sub(r);
+  });
+  const roundBoxNormal = Fn(([p, b, r]) => {
+    const s = sign(p);
+    const q = abs(p);
+    const inner = max2(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 = length2(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 = length2(v);
+    return select(n.greaterThan(1e-4), v.div(max2(n, 1e-4)), fallback);
+  });
+  const group = new Group();
+  const geometries = [];
+  const materials = [];
+  const meshes = [];
+  const levelUniforms = Array.from({ length: LEVELS }, () => ({
+    origin: uniform2(new Vector22(0, 0)),
+    dims: uniform2(new Vector22(1, 1)),
+    spacing: uniform2(20),
+    alpha: uniform2(0),
+    skipMod: uniform2(0)
+  }));
+  for (let level = 0; level < LEVELS; level++) {
+    const lu = levelUniforms[level];
+    const vUv = varying(vec2(0, 0), `vMagnetUv${level}`);
+    const vAlpha = varying(float2(0), `vMagnetAlpha${level}`);
+    const vertexNode = Fn(() => {
+      const iid = float2(instanceIndex);
+      const cols = lu.dims.x;
+      const col = mod(iid, cols).floor();
+      const row = iid.div(cols).floor();
+      const world = lu.origin.add(vec2(col, row)).mul(lu.spacing);
+      const screen = world.sub(uCam).mul(uZoom);
+      const field = vec2(0, 0).toVar();
+      const minD = float2(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(max2(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(min2(minD, d));
+        const dist = max2(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 = length2(field);
+      const influence = select(uDotMode.greaterThan(0.5), mag.div(mag.add(1)), clamp2(mag, 0, 1));
+      const corner = positionGeometry2.xy;
+      const dotRadius = mix2(uRestRadius, uHalfLen.mul(1.05), influence);
+      const dotLocal = corner.mul(dotRadius);
+      const dir = select(
+        uAlwaysAlign.greaterThan(0.5),
+        fieldDir,
+        safeNormalize(mix2(REST, fieldDir, influence), REST)
+      );
+      const nrm = vec2(dir.y.negate(), dir.x);
+      const nLen = mix2(uHalfLen.mul(0.55), uHalfLen.mul(1.35), influence);
+      const nWid = mix2(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), float2(0.72), float2(0.35));
+      const fieldAlpha = mix2(restAlpha, float2(1), influence);
+      const alpha = clamp2(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),
+        float2(1).sub(pos.y.div(uView.y).mul(2))
+      );
+      return vec42(ndc, 0, 1);
+    })();
+    const fragmentNode = Fn(() => {
+      const dotEdge = float2(1).sub(smoothstep2(0.62, 1, length2(vUv)));
+      const ax = float2(1).sub(smoothstep2(0.55, 1, abs(vUv.x)));
+      const ay = float2(1).sub(smoothstep2(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 vec42(uColor, a);
+    })();
+    const material = new MeshBasicNodeMaterial2();
+    material.vertexNode = vertexNode;
+    material.fragmentNode = fragmentNode;
+    material.transparent = true;
+    material.depthTest = false;
+    material.depthWrite = false;
+    const geometry = new InstancedBufferGeometry();
+    geometry.setAttribute("position", new BufferAttribute2(CORNERS, 3));
+    geometry.instanceCount = 0;
+    const mesh = new Mesh2(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.ts
+function mergeGridConfig(base, next) {
+  const merged = { ...base, ...next };
+  if (next.magnet !== void 0) merged.magnet = { ...base.magnet, ...next.magnet };
+  return merged;
+}
+function createGridPass(initial = {}, deps = {}) {
+  let cfg = mergeGridConfig(DEFAULT_GRID_CONFIG, initial);
+  const group = new Group2();
+  const classic = createClassicGrid(cfg);
+  group.add(classic.mesh);
+  let magnet = null;
+  const poles = deps.poles ?? [];
+  const sourceScratch = new Float32Array(MAX_MAGNET_SOURCES * MAGNET_SOURCE_FLOATS);
+  const poleScratch = [];
+  return {
+    name: "grid",
+    object: group,
+    arm(world, wake) {
+      const wakeIfWidgets = () => {
+        const m = resolveMagnet(cfg);
+        if (m.enabled && m.widgets && deps.readSpatial !== void 0) wake();
+      };
+      const wakeIfEnabled = () => {
+        if (resolveMagnet(cfg).enabled) wake();
+      };
+      const unsubs = [world.reactive.observeResource(SpatialVersion, wakeIfWidgets)];
+      for (const source of poles) unsubs.push(source.subscribe(world, wakeIfEnabled));
+      return unsubs;
+    },
+    collect(world, frame) {
+      const m = resolveMagnet(cfg);
+      if (!m.enabled) {
+        classic.mesh.visible = true;
+        if (magnet !== null) magnet.group.visible = false;
+        classic.setCamera(frame);
+        return;
+      }
+      if (magnet === null) {
+        magnet = createMagnetGrid();
+        group.add(magnet.group);
+      }
+      classic.mesh.visible = false;
+      magnet.group.visible = true;
+      const fieldScale = magnetFieldScale(frame.camera.zoom, m.fadeZoom);
+      poleScratch.length = 0;
+      if (fieldScale > 0) {
+        for (const source of poles) poleScratch.push(...source.read(world));
+      }
+      const sourceCount = collectMagnetSources(
+        world,
+        frame,
+        m,
+        fieldScale,
+        poleScratch,
+        deps.readSpatial,
+        sourceScratch
+      );
+      const levels = collectMagnetLevels(frame, cfg);
+      magnet.update(frame, cfg, m, levels, sourceScratch, sourceCount);
+    },
+    configure(next) {
+      cfg = mergeGridConfig(cfg, next);
+      classic.configure(cfg);
+    },
+    dispose() {
+      classic.dispose();
+      magnet?.dispose();
+      magnet = null;
+    }
+  };
+}
+
+// ../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 BufferAttribute3, BufferGeometry as BufferGeometry2, DoubleSide, Mesh as Mesh3, MeshBasicNodeMaterial as MeshBasicNodeMaterial3 } from "three/webgpu";
+function createSoupMesh(renderOrder) {
+  const material = new MeshBasicNodeMaterial3();
+  material.fragmentNode = attribute("color", "vec4");
+  material.transparent = true;
+  material.depthTest = false;
+  material.depthWrite = false;
+  material.side = DoubleSide;
+  let geometry = new BufferGeometry2();
+  let capacity = 0;
+  const mesh = new Mesh3(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 BufferGeometry2();
+        const pos = new Float32Array(capacity * 3);
+        const col = new Float32Array(capacity * 4);
+        pos.set(soup.positions);
+        col.set(soup.colors);
+        geometry.setAttribute("position", new BufferAttribute3(pos, 3));
+        geometry.setAttribute("color", new BufferAttribute3(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 };
@@ -682,12 +1131,53 @@ function createGroundRenderer(doc, opts = {}) {
   };
 }
 
+// ../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 grid = createGridPass(opts.grid ?? {});
+    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 ?? []];
@@ -704,12 +1194,20 @@ function ground(opts = {}) {
 }
 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,
-  parseCssColor
+  localPointerPoles,
+  magnetFieldScale,
+  parseCssColor,
+  resolveMagnet
 };
 //# sourceMappingURL=ground.js.map