@aethervtt/shard-structure 0.0.0-stage → 0.1.0

package/dist/interior.js

@@ -0,0 +1,645 @@
+import {
+  COVER_SCALE,
+  COVER_ZERO,
+  LINK_X,
+  LINK_Z,
+  ROW_CLEAR,
+  ROW_SCALE,
+  ROW_ZERO,
+  VISIBILITY_MAX
+} from "@aethervtt/shard-render";
+class FieldLayer {
+  /** Cover top y over the layer's base, per texel; Infinity where uncovered. */
+  cover;
+  /** LINK_X | LINK_Z: flux to the +x and +z neighbour is blocked. */
+  links;
+  /** The solve's visibility, before the blur: a region re-solve starts from it. */
+  value;
+  /** What uploads: blurred visibility, links and cover, packed (see `packTexel`). */
+  packed;
+  /** The y cover heights count from: the level's elevation (the ground level's is 0). */
+  base = 0;
+  constructor(width, height) {
+    const n = width * height;
+    this.cover = new Float32Array(n).fill(Number.POSITIVE_INFINITY);
+    this.links = new Uint8Array(n);
+    this.value = new Float32Array(n).fill(1);
+    this.packed = new Uint32Array(n);
+  }
+}
+class SolveScratch {
+  blurred = new Float32Array(0);
+  /** Per texel: neighbours reached, and 1 / (their count + κ). */
+  mask = new Uint8Array(0);
+  inv = new Float32Array(0);
+  /** Per tile: how far its texels moved in the last sweep, and in this one. */
+  moved = new Float32Array(0);
+  movedNext = new Float32Array(0);
+  crossings = new Float64Array(64);
+  /** Aggregation (the coarse pass): aggregate per texel, and per aggregate its sums. */
+  agg = new Int32Array(0);
+  aggValue = new Float64Array(0);
+  aggDiag = new Float64Array(0);
+  aggRhs = new Float64Array(0);
+  /** Coarse couplings as CSR. */
+  rowStart = new Int32Array(0);
+  colIndex = new Int32Array(0);
+  weight = new Float64Array(0);
+  stack = new Int32Array(0);
+  ensure(n) {
+    if (this.blurred.length < n) this.blurred = new Float32Array(n);
+    if (this.mask.length < n) {
+      this.mask = new Uint8Array(n);
+      this.inv = new Float32Array(n);
+    }
+    if (this.agg.length < n) {
+      this.agg = new Int32Array(n);
+      this.stack = new Int32Array(n);
+    }
+  }
+}
+function clipRect(grid, r) {
+  return {
+    x0: Math.max(0, r.x0),
+    z0: Math.max(0, r.z0),
+    x1: Math.min(grid.width, r.x1),
+    z1: Math.min(grid.height, r.z1)
+  };
+}
+function texelsOf(grid, b, grow) {
+  const t = grid.texel;
+  return clipRect(grid, {
+    x0: Math.floor((b.minX - grow - grid.ox) / t - 0.5),
+    z0: Math.floor((b.minZ - grow - grid.oz) / t - 0.5),
+    x1: Math.ceil((b.maxX + grow - grid.ox) / t - 0.5) + 1,
+    z1: Math.ceil((b.maxZ + grow - grid.oz) / t - 0.5) + 1
+  });
+}
+function rasterCover(grid, layer, cover, rect, base, scratch) {
+  const f = cover.shape;
+  const t = grid.texel;
+  const z0 = Math.max(rect.z0, Math.floor((f.minZ - grid.oz) / t - 0.5));
+  const z1 = Math.min(rect.z1, Math.ceil((f.maxZ - grid.oz) / t - 0.5) + 1);
+  const rings = f.rings.length - 1;
+  for (let z = z0; z < z1; z++) {
+    const zc = grid.oz + (z + 0.5) * t;
+    let n = 0;
+    for (let r = 0; r < rings; r++) {
+      if (r > 0 && cover.closed.includes(r)) continue;
+      n = crossings(f.points, f.rings[r], f.rings[r + 1], zc, scratch, n);
+    }
+    fillSpans(grid, layer, f, rect, z, zc, base, scratch.crossings, n);
+    for (const r of cover.closed) {
+      const m = crossings(f.points, f.rings[r], f.rings[r + 1], zc, scratch, 0);
+      fillSpans(grid, layer, f, rect, z, zc, base, scratch.crossings, m);
+    }
+  }
+}
+function crossings(p, start, end, zc, scratch, n) {
+  for (let i = start, j = end - 1; i < end; j = i++) {
+    const zi = p[i * 2 + 1];
+    const zj = p[j * 2 + 1];
+    if (zi > zc === zj > zc) continue;
+    const xi = p[i * 2];
+    const xj = p[j * 2];
+    if (n >= scratch.crossings.length) {
+      const grown = new Float64Array(scratch.crossings.length * 2);
+      grown.set(scratch.crossings);
+      scratch.crossings = grown;
+    }
+    scratch.crossings[n++] = xi + (zc - zi) * (xj - xi) / (zj - zi);
+  }
+  return n;
+}
+function fillSpans(grid, layer, f, rect, z, zc, base, xs, n) {
+  const list = xs.subarray(0, n).sort();
+  const t = grid.texel;
+  const w = grid.width;
+  for (let k = 0; k + 1 < n; k += 2) {
+    const a = Math.max(rect.x0, Math.ceil((list[k] - grid.ox) / t - 0.5));
+    const b = Math.min(rect.x1, Math.ceil((list[k + 1] - grid.ox) / t - 0.5));
+    for (let x = a; x < b; x++) {
+      const xc = grid.ox + (x + 0.5) * t;
+      const y = f.elevation + f.slope * (xc * f.rx + zc * f.rz - f.d0) - base;
+      const i = z * w + x;
+      if (y < layer.cover[i]) layer.cover[i] = y;
+    }
+  }
+}
+function rasterBarrier(grid, layer, s, rect) {
+  const t = grid.texel;
+  const w = grid.width;
+  const eps = 1e-6;
+  const dx = s.bx - s.ax;
+  const dz = s.bz - s.az;
+  if (Math.abs(dz) > 1e-12) {
+    const lo = Math.min(s.az, s.bz) - eps;
+    const hi = Math.max(s.az, s.bz) + eps;
+    const z0 = Math.max(rect.z0, Math.ceil((lo - grid.oz) / t - 0.5));
+    const z1 = Math.min(rect.z1 - 1, Math.floor((hi - grid.oz) / t - 0.5));
+    for (let z = z0; z <= z1; z++) {
+      const zc = grid.oz + (z + 0.5) * t;
+      const u = Math.min(1, Math.max(0, (zc - s.az) / dz));
+      const x = s.ax + u * dx;
+      const f = (x - grid.ox) / t - 0.5;
+      let i = Math.floor(f);
+      markX(layer, rect, w, i, z);
+      if (Math.abs(f - Math.round(f)) < 1e-9) {
+        i = Math.round(f);
+        markX(layer, rect, w, i - 1, z);
+        markX(layer, rect, w, i, z);
+      }
+    }
+  }
+  if (Math.abs(dx) > 1e-12) {
+    const lo = Math.min(s.ax, s.bx) - eps;
+    const hi = Math.max(s.ax, s.bx) + eps;
+    const x0 = Math.max(rect.x0, Math.ceil((lo - grid.ox) / t - 0.5));
+    const x1 = Math.min(rect.x1 - 1, Math.floor((hi - grid.ox) / t - 0.5));
+    for (let x = x0; x <= x1; x++) {
+      const xc = grid.ox + (x + 0.5) * t;
+      const u = Math.min(1, Math.max(0, (xc - s.ax) / dx));
+      const z = s.az + u * dz;
+      const f = (z - grid.oz) / t - 0.5;
+      let j = Math.floor(f);
+      markZ(layer, rect, w, x, j);
+      if (Math.abs(f - Math.round(f)) < 1e-9) {
+        j = Math.round(f);
+        markZ(layer, rect, w, x, j - 1);
+        markZ(layer, rect, w, x, j);
+      }
+    }
+  }
+}
+function markX(layer, rect, w, x, z) {
+  if (x >= rect.x0 && x < rect.x1 && z >= rect.z0 && z < rect.z1) layer.links[z * w + x] |= LINK_X;
+}
+function markZ(layer, rect, w, x, z) {
+  if (x >= rect.x0 && x < rect.x1 && z >= rect.z0 && z < rect.z1) layer.links[z * w + x] |= LINK_Z;
+}
+function clearRect(grid, layer, rect) {
+  const w = grid.width;
+  for (let z = rect.z0; z < rect.z1; z++) {
+    layer.cover.fill(Number.POSITIVE_INFINITY, z * w + rect.x0, z * w + rect.x1);
+    layer.links.fill(0, z * w + rect.x0, z * w + rect.x1);
+  }
+}
+function screening(texel, reach) {
+  return texel * texel / Math.max(reach * reach, 1e-12);
+}
+function relaxation(kappa) {
+  const rho = 4 / (4 + kappa);
+  return 2 / (1 + Math.sqrt(1 - rho * rho));
+}
+const TILE = 16;
+function solveRect(grid, layer, rect, options, scratch) {
+  const w = grid.width;
+  const h = grid.height;
+  const kappa = screening(grid.texel, options.reach);
+  const omega = relaxation(kappa);
+  const tolerance = options.tolerance ?? 1e-4;
+  const maxSweeps = options.maxSweeps ?? 2e3;
+  const v = layer.value;
+  const cover = layer.cover;
+  const links = layer.links;
+  scratch.ensure(w * h);
+  const mask = scratch.mask;
+  const inv = scratch.inv;
+  const linkX = LINK_X;
+  const linkZ = LINK_Z;
+  let texels = 0;
+  for (let z = rect.z0; z < rect.z1; z++) {
+    for (let x = rect.x0; x < rect.x1; x++) {
+      const i = z * w + x;
+      if (cover[i] === Number.POSITIVE_INFINITY) {
+        v[i] = 1;
+        mask[i] = 0;
+        continue;
+      }
+      texels++;
+      let m = 16;
+      let n = 0;
+      if (x + 1 < w && (links[i] & linkX) === 0) {
+        m |= 1;
+        n++;
+      }
+      if (x > 0 && (links[i - 1] & linkX) === 0) {
+        m |= 2;
+        n++;
+      }
+      if (z + 1 < h && (links[i] & linkZ) === 0) {
+        m |= 4;
+        n++;
+      }
+      if (z > 0 && (links[i - w] & linkZ) === 0) {
+        m |= 8;
+        n++;
+      }
+      mask[i] = m;
+      inv[i] = 1 / (n + kappa);
+    }
+  }
+  let coarseSweeps = 0;
+  if (options.coarse && texels > 0)
+    coarseSweeps = coarsePass(grid, layer, rect, kappa, options.coarseCells ?? 4, scratch);
+  let sweeps = 0;
+  if (texels > 0) {
+    const tx = Math.ceil((rect.x1 - rect.x0) / TILE);
+    const tz = Math.ceil((rect.z1 - rect.z0) / TILE);
+    const tiles = tx * tz;
+    if (scratch.moved.length < tiles) {
+      scratch.moved = new Float32Array(tiles);
+      scratch.movedNext = new Float32Array(tiles);
+    }
+    let moved = scratch.moved;
+    let next = scratch.movedNext;
+    moved.fill(1, 0, tiles);
+    for (; sweeps < maxSweeps; sweeps++) {
+      let most = 0;
+      for (let b = 0; b < tz; b++) {
+        for (let a = 0; a < tx; a++) {
+          const t = b * tx + a;
+          if (moved[t] < tolerance && (a === 0 || moved[t - 1] < tolerance) && (a + 1 === tx || moved[t + 1] < tolerance) && (b === 0 || moved[t - tx] < tolerance) && (b + 1 === tz || moved[t + tx] < tolerance)) {
+            next[t] = 0;
+            continue;
+          }
+          let tileMost = 0;
+          const x0 = rect.x0 + a * TILE;
+          const x1 = Math.min(rect.x1, x0 + TILE);
+          const z0 = rect.z0 + b * TILE;
+          const z1 = Math.min(rect.z1, z0 + TILE);
+          for (let z = z0; z < z1; z++) {
+            for (let i = z * w + x0, end = z * w + x1; i < end; i++) {
+              const m = mask[i];
+              if (m === 0) continue;
+              let sum = 0;
+              if (m & 1) sum += v[i + 1];
+              if (m & 2) sum += v[i - 1];
+              if (m & 4) sum += v[i + w];
+              if (m & 8) sum += v[i - w];
+              const old = v[i];
+              let value = old + omega * (sum * inv[i] - old);
+              if (value < 0) value = 0;
+              else if (value > 1) value = 1;
+              v[i] = value;
+              const d = value > old ? value - old : old - value;
+              if (d > tileMost) tileMost = d;
+            }
+          }
+          next[t] = tileMost;
+          if (tileMost > most) most = tileMost;
+        }
+      }
+      const swap = moved;
+      moved = next;
+      next = swap;
+      if (most < tolerance) {
+        sweeps++;
+        break;
+      }
+    }
+    scratch.moved = moved;
+    scratch.movedNext = next;
+  }
+  return { texels, sweeps, coarseSweeps };
+}
+function coarsePass(grid, layer, rect, kappa, cells, scratch) {
+  const w = grid.width;
+  const n = w * grid.height;
+  scratch.ensure(n);
+  const agg = scratch.agg;
+  const cover = layer.cover;
+  const links = layer.links;
+  const v = layer.value;
+  const stack = scratch.stack;
+  for (let z = rect.z0; z < rect.z1; z++) agg.fill(-1, z * w + rect.x0, z * w + rect.x1);
+  let count = 0;
+  for (let z = rect.z0; z < rect.z1; z++) {
+    for (let x = rect.x0; x < rect.x1; x++) {
+      const seed = z * w + x;
+      if (agg[seed] !== -1 || cover[seed] === Number.POSITIVE_INFINITY) continue;
+      const bx = Math.floor((x - rect.x0) / cells);
+      const bz = Math.floor((z - rect.z0) / cells);
+      const id = count++;
+      let top = 0;
+      stack[top++] = seed;
+      agg[seed] = id;
+      while (top > 0) {
+        const i = stack[--top];
+        const ix = i % w;
+        const iz = (i - ix) / w;
+        for (let k = 0; k < 4; k++) {
+          let j;
+          let open;
+          if (k === 0) {
+            j = i + 1;
+            open = ix + 1 < rect.x1 && (links[i] & LINK_X) === 0;
+          } else if (k === 1) {
+            j = i - 1;
+            open = ix > rect.x0 && (links[i - 1] & LINK_X) === 0;
+          } else if (k === 2) {
+            j = i + w;
+            open = iz + 1 < rect.z1 && (links[i] & LINK_Z) === 0;
+          } else {
+            j = i - w;
+            open = iz > rect.z0 && (links[i - w] & LINK_Z) === 0;
+          }
+          if (!open || agg[j] !== -1 || cover[j] === Number.POSITIVE_INFINITY) continue;
+          const jx = j % w;
+          const jz = (j - jx) / w;
+          if (Math.floor((jx - rect.x0) / cells) !== bx || Math.floor((jz - rect.z0) / cells) !== bz)
+            continue;
+          agg[j] = id;
+          stack[top++] = j;
+        }
+      }
+    }
+  }
+  if (count === 0) return 0;
+  if (scratch.aggValue.length < count) {
+    scratch.aggValue = new Float64Array(count * 2);
+    scratch.aggDiag = new Float64Array(count * 2);
+    scratch.aggRhs = new Float64Array(count * 2);
+    scratch.rowStart = new Int32Array(count * 2 + 1);
+  }
+  const diag = scratch.aggDiag;
+  const rhs = scratch.aggRhs;
+  const value = scratch.aggValue;
+  diag.fill(0, 0, count);
+  rhs.fill(0, 0, count);
+  const scale = 1 / cells;
+  const pairs = /* @__PURE__ */ new Map();
+  const h = grid.height;
+  const aggIn = (i) => {
+    const x = i % w;
+    const z = (i - x) / w;
+    return x >= rect.x0 && x < rect.x1 && z >= rect.z0 && z < rect.z1 ? agg[i] : -1;
+  };
+  const pair = (i, j) => {
+    const a = aggIn(i);
+    const b = aggIn(j);
+    if (a === b) return;
+    if (a >= 0 && b >= 0) {
+      diag[a] = diag[a] + scale;
+      diag[b] = diag[b] + scale;
+      const key = a < b ? a * count + b : b * count + a;
+      pairs.set(key, (pairs.get(key) ?? 0) + scale);
+    } else if (a >= 0) {
+      diag[a] = diag[a] + scale;
+      rhs[a] = rhs[a] + scale * v[j];
+    } else {
+      diag[b] = diag[b] + scale;
+      rhs[b] = rhs[b] + scale * v[i];
+    }
+  };
+  for (let z = Math.max(0, rect.z0 - 1); z < Math.min(h, rect.z1 + 1); z++) {
+    for (let x = Math.max(0, rect.x0 - 1); x < Math.min(w, rect.x1 + 1); x++) {
+      const i = z * w + x;
+      const a = aggIn(i);
+      if (a >= 0) diag[a] = diag[a] + kappa;
+      if (x + 1 < w && (links[i] & LINK_X) === 0) pair(i, i + 1);
+      if (z + 1 < h && (links[i] & LINK_Z) === 0) pair(i, i + w);
+    }
+  }
+  const rowStart = scratch.rowStart;
+  rowStart.fill(0, 0, count + 1);
+  for (const key of pairs.keys()) {
+    const a = Math.floor(key / count);
+    const b = key - a * count;
+    rowStart[a + 1]++;
+    rowStart[b + 1]++;
+  }
+  for (let a = 0; a < count; a++) rowStart[a + 1] = rowStart[a + 1] + rowStart[a];
+  const nnz = rowStart[count];
+  if (scratch.colIndex.length < nnz) {
+    scratch.colIndex = new Int32Array(nnz * 2);
+    scratch.weight = new Float64Array(nnz * 2);
+  }
+  const col = scratch.colIndex;
+  const weight = scratch.weight;
+  const fill = new Int32Array(count);
+  for (const [key, g] of pairs) {
+    const a = Math.floor(key / count);
+    const b = key - a * count;
+    let o = rowStart[a] + fill[a]++;
+    col[o] = b;
+    weight[o] = g;
+    o = rowStart[b] + fill[b]++;
+    col[o] = a;
+    weight[o] = g;
+  }
+  value.fill(0, 0, count);
+  const coarseKappa = kappa * cells * cells;
+  const omega = relaxation(coarseKappa);
+  let sweeps = 0;
+  for (; sweeps < 500; sweeps++) {
+    let moved = 0;
+    for (let a = 0; a < count; a++) {
+      let sum = rhs[a];
+      for (let o = rowStart[a]; o < rowStart[a + 1]; o++) sum += weight[o] * value[col[o]];
+      const old = value[a];
+      const next = Math.min(1, Math.max(0, old + omega * (sum / diag[a] - old)));
+      value[a] = next;
+      const d = Math.abs(next - old);
+      if (d > moved) moved = d;
+    }
+    if (moved < 1e-5) break;
+  }
+  for (let z = rect.z0; z < rect.z1; z++)
+    for (let x = rect.x0; x < rect.x1; x++) {
+      const i = z * w + x;
+      if (agg[i] >= 0) v[i] = value[agg[i]];
+    }
+  return sweeps + 1;
+}
+function packRect(grid, layer, rect, scratch) {
+  const w = grid.width;
+  const h = grid.height;
+  scratch.ensure(w * h);
+  const v = layer.value;
+  const links = layer.links;
+  const cover = layer.cover;
+  const packed = layer.packed;
+  const visMax = VISIBILITY_MAX;
+  const coverScale = COVER_SCALE;
+  const coverZero = COVER_ZERO;
+  const linkX = LINK_X;
+  const linkZ = LINK_Z;
+  for (let z = rect.z0; z < rect.z1; z++) {
+    for (let x = rect.x0; x < rect.x1; x++) {
+      const i = z * w + x;
+      const c = cover[i];
+      if (c === Number.POSITIVE_INFINITY) {
+        packed[i] = visMax << 2 | links[i] & 3;
+        continue;
+      }
+      let out;
+      {
+        let sum = 4 * v[i];
+        let n = 4;
+        if (x + 1 < w && (links[i] & linkX) === 0) {
+          sum += v[i + 1];
+          n++;
+        }
+        if (x > 0 && (links[i - 1] & linkX) === 0) {
+          sum += v[i - 1];
+          n++;
+        }
+        if (z + 1 < h && (links[i] & linkZ) === 0) {
+          sum += v[i + w];
+          n++;
+        }
+        if (z > 0 && (links[i - w] & linkZ) === 0) {
+          sum += v[i - w];
+          n++;
+        }
+        out = sum / n;
+      }
+      const vis = Math.min(1, Math.max(0, out)) * visMax + 0.5 | 0;
+      let code = Math.round(c * coverScale) + coverZero;
+      code = code < 1 ? 1 : code > 65535 ? 65535 : code;
+      packed[i] = (code << 16 | vis << 2 | links[i] & 3) >>> 0;
+    }
+  }
+}
+function packTexel(visibility, links, cover) {
+  const vis = Math.round(Math.min(1, Math.max(0, visibility)) * VISIBILITY_MAX);
+  const code = cover === Number.POSITIVE_INFINITY ? 0 : Math.min(65535, Math.max(1, Math.round(cover * COVER_SCALE) + COVER_ZERO));
+  return (code << 16 | vis << 2 | links & 3) >>> 0;
+}
+function unpackVisibility(texel) {
+  return ((texel & 65535) >>> 2) / VISIBILITY_MAX;
+}
+const directions = /* @__PURE__ */ new Map();
+function binOf(x, z) {
+  const t = z / (Math.abs(x) + Math.abs(z));
+  const p = x < 0 ? 2 - t : t >= 0 ? t : 4 + t;
+  const u = p * 0.25 + 0.5;
+  return u - Math.floor(u);
+}
+function directionAt(u, out, k, sin) {
+  let p = (u - 0.5) * 4;
+  if (p < 0) p += 4;
+  let x;
+  let z;
+  if (p < 1) {
+    z = p;
+    x = 1 - p;
+  } else if (p < 3) {
+    z = 2 - p;
+    x = -(1 - Math.abs(z));
+  } else {
+    z = p - 4;
+    x = 1 - Math.abs(z);
+  }
+  const len = Math.sqrt(x * x + z * z);
+  out[k] = x / len;
+  sin[k] = z / len;
+}
+function binDirections(bins) {
+  let d = directions.get(bins);
+  if (!d) {
+    d = { cos: new Float64Array(bins), sin: new Float64Array(bins) };
+    for (let k = 0; k < bins; k++) directionAt((k + 0.5) / bins, d.cos, k, d.sin);
+    directions.set(bins, d);
+  }
+  return d;
+}
+class RowScratch {
+  distance = new Float64Array(0);
+  top = new Float64Array(0);
+  ensure(bins) {
+    if (this.distance.length < bins) {
+      this.distance = new Float64Array(bins);
+      this.top = new Float64Array(bins);
+    }
+  }
+}
+function rowBias(thickness) {
+  return Math.min(thickness / 4, 0.05);
+}
+function buildRow(out, x, y, z, range, barriers, count, scratch) {
+  const bins = out.length;
+  scratch.ensure(bins);
+  const dist = scratch.distance;
+  const top = scratch.top;
+  dist.fill(Number.POSITIVE_INFINITY, 0, bins);
+  const { cos, sin } = binDirections(bins);
+  for (let n = 0; n < count; n++) {
+    const s = barriers[n];
+    const ax = s.ax - x;
+    const az = s.az - z;
+    const ex = s.bx - s.ax;
+    const ez = s.bz - s.az;
+    const l2 = ex * ex + ez * ez;
+    if (l2 < 1e-12) continue;
+    const u0 = Math.min(1, Math.max(0, -(ax * ex + az * ez) / l2));
+    const px = ax + u0 * ex;
+    const pz = az + u0 * ez;
+    const near = Math.sqrt(px * px + pz * pz);
+    if (near > range || near < 1e-6) continue;
+    const ua = binOf(ax, az);
+    const ub = binOf(ax + ex, az + ez);
+    let span = ub - ua;
+    if (span > 0.5) span -= 1;
+    else if (span < -0.5) span += 1;
+    const start = span >= 0 ? ua : ub;
+    const k0 = Math.ceil(start * bins - 0.5);
+    const k1 = Math.floor((start + Math.abs(span)) * bins - 0.5);
+    const bias = rowBias(s.thickness);
+    for (let kk = k0; kk <= k1; kk++) {
+      const k = (kk % bins + bins) % bins;
+      const dx = cos[k];
+      const dz = sin[k];
+      const denom = dx * ez - dz * ex;
+      if (Math.abs(denom) < 1e-12) continue;
+      const t = (ax * ez - az * ex) / denom;
+      const u = (ax * dz - az * dx) / denom;
+      if (t <= 0 || t > range || u < -1e-9 || u > 1 + 1e-9) continue;
+      const r = t + bias;
+      if (r < dist[k]) {
+        dist[k] = r;
+        top[k] = s.top;
+      }
+    }
+  }
+  for (let k = 0; k < bins; k++) {
+    const r = dist[k];
+    if (r === Number.POSITIVE_INFINITY) {
+      out[k] = ROW_CLEAR;
+      continue;
+    }
+    const d = Math.min(65534, Math.round(r * ROW_SCALE));
+    const h = Math.min(65535, Math.max(0, Math.round((top[k] - y) * ROW_SCALE) + ROW_ZERO));
+    out[k] = (h << 16 | d) >>> 0;
+  }
+}
+function unpackBin(bin) {
+  const d = bin & 65535;
+  return {
+    distance: d === 65535 ? Number.POSITIVE_INFINITY : d / ROW_SCALE,
+    top: ((bin >>> 16) - ROW_ZERO) / ROW_SCALE
+  };
+}
+export {
+  FieldLayer,
+  LINK_X,
+  LINK_Z,
+  RowScratch,
+  SolveScratch,
+  binOf,
+  buildRow,
+  clearRect,
+  clipRect,
+  packRect,
+  packTexel,
+  rasterBarrier,
+  rasterCover,
+  relaxation,
+  rowBias,
+  screening,
+  solveRect,
+  texelsOf,
+  unpackBin,
+  unpackVisibility
+};

package/dist/planar.d.ts

@@ -0,0 +1,61 @@
+import { type WallCurve } from './curve.js';
+export type Channel = 'none' | 'normal';
+/** A light channel (0069): `sight`, or absent, follows the sight channel. */
+export type LightChannel = Channel | 'sight';
+export interface PlanarWall {
+    id: string;
+    a: readonly [number, number];
+    b: readonly [number, number];
+    /** Curved walls (0066); straight when absent. */
+    shape?: WallCurve;
+    bow?: number;
+    c0?: readonly [number, number];
+    c1?: readonly [number, number];
+    /** The level it stands on (0067); none or null is the ground level. */
+    level?: string | null;
+    /** Whether its spans block light (0069); absent or `sight` follows sight (a wall's always blocks). */
+    light?: LightChannel;
+}
+export interface PlanarOptions {
+    /** Chord tolerance for curved walls: StructureSettings.curveTolerance. Default 0.01. */
+    tolerance?: number;
+    /** Only this level's walls (null: the ground level), each segment tagged with it (0067). */
+    level?: string | null;
+}
+export interface PlanarOpening {
+    id: string;
+    /** The host wall's id. */
+    wall: string;
+    kind: 'door' | 'window';
+    offset: number;
+    width: number;
+    /** Doors only; an open door blocks nothing. */
+    state?: 'closed' | 'open' | 'locked';
+    sight: Channel;
+    movement: Channel;
+    /** Whether it blocks light when closed (0069); absent or `sight` follows sight. */
+    light?: LightChannel;
+}
+export interface Segment {
+    /** `struct:<wall>:<start>` for wall spans, `struct-opening:<opening>` for openings. */
+    id: string;
+    sourceWallId: string;
+    openingId?: string;
+    a: [number, number];
+    b: [number, number];
+    sight: Channel;
+    movement: Channel;
+    /** Present when its wall or opening sets a light channel (0069); absent follows sight. */
+    light?: Channel;
+    /** Its wall's level: present when the wall names one or `level` was asked for (0067). */
+    level?: string | null;
+}
+/** Whether a segment blocks light (0069): its light channel, or its sight channel when unset. */
+export declare function lightChannel(segment: Segment): Channel;
+/**
+ * Splits walls into barrier segments: solid spans block both channels; an opening's span carries
+ * its own channels, and an open door's carries neither. Openings sort by offset, then id; offsets
+ * are arc lengths on curved walls. A curved span becomes one segment per sample interval: the
+ * first keeps the span's id, the rest append `~1`, `~2`, … With `level`, only that level's walls.
+ */
+export declare function planarBarriers(walls: readonly PlanarWall[], openings: readonly PlanarOpening[], options?: PlanarOptions): Segment[];