@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/chunk-jq4e17tj.js

@@ -0,0 +1,1031 @@
+import {
+  notImplemented2,
+  triangleCount2,
+  boundsOf2,
+  merge2,
+  worldTransforms2,
+  toWorld2,
+  worldMeshes2
+} from "./chunk-hg7pf34j.js";
+
+// src/qa/geometry.ts
+var at = (m, i) => [
+  m.positions[i * 3] ?? 0,
+  m.positions[i * 3 + 1] ?? 0,
+  m.positions[i * 3 + 2] ?? 0
+];
+var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var lerp = (a, b, t) => [
+  a[0] + (b[0] - a[0]) * t,
+  a[1] + (b[1] - a[1]) * t,
+  a[2] + (b[2] - a[2]) * t
+];
+function triangle(m, t) {
+  return [
+    at(m, m.indices[t * 3] ?? 0),
+    at(m, m.indices[t * 3 + 1] ?? 0),
+    at(m, m.indices[t * 3 + 2] ?? 0)
+  ];
+}
+function pointTriangleDistance2(p, a, b, c) {
+  const ab = sub(b, a);
+  const ac = sub(c, a);
+  const ap = sub(p, a);
+  const d1 = dot(ab, ap);
+  const d2 = dot(ac, ap);
+  if (d1 <= 0 && d2 <= 0)
+    return Math.hypot(...ap);
+  const bp = sub(p, b);
+  const d3 = dot(ab, bp);
+  const d4 = dot(ac, bp);
+  if (d3 >= 0 && d4 <= d3)
+    return Math.hypot(...bp);
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0)
+    return Math.hypot(...sub(p, lerp(a, b, d1 / (d1 - d3))));
+  const cp = sub(p, c);
+  const d5 = dot(ab, cp);
+  const d6 = dot(ac, cp);
+  if (d6 >= 0 && d5 <= d6)
+    return Math.hypot(...cp);
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0)
+    return Math.hypot(...sub(p, lerp(a, c, d2 / (d2 - d6))));
+  const va = d3 * d6 - d5 * d4;
+  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0)
+    return Math.hypot(...sub(p, lerp(b, c, (d4 - d3) / (d4 - d3 + (d5 - d6)))));
+  const den = 1 / (va + vb + vc);
+  const v = vb * den;
+  const w = vc * den;
+  return Math.hypot(...sub(p, [
+    a[0] + ab[0] * v + ac[0] * w,
+    a[1] + ab[1] * v + ac[1] * w,
+    a[2] + ab[2] * v + ac[2] * w
+  ]));
+}
+var key = (x, y, z) => x * 73856093 ^ y * 19349663 ^ z * 83492791 | 0;
+
+class TriangleGrid2 {
+  cells = new Map;
+  cell;
+  tris;
+  boxes;
+  stamp;
+  query = 0;
+  constructor(mesh) {
+    const n = mesh.indices.length / 3;
+    this.tris = new Float64Array(n * 9);
+    this.boxes = new Float64Array(n * 6);
+    this.stamp = new Int32Array(n);
+    const b = boundsOf2(mesh);
+    const diag = Math.hypot(b.max[0] - b.min[0], b.max[1] - b.min[1], b.max[2] - b.min[2]);
+    this.cell = Math.max(0.25, diag / 256);
+    const CELL = this.cell;
+    for (let t = 0;t < n; t++) {
+      const [a, b, c] = triangle(mesh, t);
+      this.tris.set([...a, ...b, ...c], t * 9);
+      for (let k = 0;k < 3; k++) {
+        this.boxes[t * 6 + k] = Math.min(a[k] ?? 0, b[k] ?? 0, c[k] ?? 0);
+        this.boxes[t * 6 + 3 + k] = Math.max(a[k] ?? 0, b[k] ?? 0, c[k] ?? 0);
+      }
+      const lo = [0, 1, 2].map((k) => Math.floor(Math.min(a[k] ?? 0, b[k] ?? 0, c[k] ?? 0) / CELL));
+      const hi = [0, 1, 2].map((k) => Math.floor(Math.max(a[k] ?? 0, b[k] ?? 0, c[k] ?? 0) / CELL));
+      for (let x = lo[0] ?? 0;x <= (hi[0] ?? 0); x++)
+        for (let y = lo[1] ?? 0;y <= (hi[1] ?? 0); y++)
+          for (let z = lo[2] ?? 0;z <= (hi[2] ?? 0); z++) {
+            const k = key(x, y, z);
+            const list = this.cells.get(k);
+            if (list)
+              list.push(t);
+            else
+              this.cells.set(k, [t]);
+          }
+    }
+  }
+  nearest(p, radius) {
+    const CELL = this.cell;
+    const [x0, y0, z0] = [
+      Math.floor((p[0] - radius) / CELL),
+      Math.floor((p[1] - radius) / CELL),
+      Math.floor((p[2] - radius) / CELL)
+    ];
+    const [x1, y1, z1] = [
+      Math.floor((p[0] + radius) / CELL),
+      Math.floor((p[1] + radius) / CELL),
+      Math.floor((p[2] + radius) / CELL)
+    ];
+    const q = ++this.query;
+    const T = this.tris;
+    const B = this.boxes;
+    let best = Infinity;
+    for (let x = x0;x <= x1; x++)
+      for (let y = y0;y <= y1; y++)
+        for (let z = z0;z <= z1; z++) {
+          const list = this.cells.get(key(x, y, z));
+          if (!list)
+            continue;
+          for (const t of list) {
+            if (this.stamp[t] === q)
+              continue;
+            this.stamp[t] = q;
+            const lim = Math.min(best, radius);
+            const o6 = t * 6;
+            if (p[0] < (B[o6] ?? 0) - lim || p[0] > (B[o6 + 3] ?? 0) + lim || p[1] < (B[o6 + 1] ?? 0) - lim || p[1] > (B[o6 + 4] ?? 0) + lim || p[2] < (B[o6 + 2] ?? 0) - lim || p[2] > (B[o6 + 5] ?? 0) + lim)
+              continue;
+            const o = t * 9;
+            const d = pointTriangleDistance2(p, [T[o] ?? 0, T[o + 1] ?? 0, T[o + 2] ?? 0], [T[o + 3] ?? 0, T[o + 4] ?? 0, T[o + 5] ?? 0], [T[o + 6] ?? 0, T[o + 7] ?? 0, T[o + 8] ?? 0]);
+            if (d < best)
+              best = d;
+          }
+        }
+    return best <= radius ? best : Infinity;
+  }
+}
+var sampleCache = new WeakMap;
+function surfaceSamples2(m, step = 0.05, maxPerEdge = 16) {
+  const key = `${step}:${maxPerEdge}`;
+  const byMesh = sampleCache.get(m) ?? new Map;
+  sampleCache.set(m, byMesh);
+  const hit = byMesh.get(key);
+  if (hit)
+    return hit;
+  const out = sampleMesh(m, step, maxPerEdge);
+  byMesh.set(key, out);
+  return out;
+}
+function sampleMesh(m, step, maxPerEdge) {
+  const out = [];
+  for (let i = 0;i < m.positions.length / 3; i++)
+    out.push(at(m, i));
+  for (let t = 0;t < m.indices.length / 3; t++) {
+    const tri = triangle(m, t);
+    for (let e = 0;e < 3; e++) {
+      const a = tri[e] ?? tri[0];
+      const b = tri[(e + 1) % 3] ?? tri[0];
+      const n = Math.min(maxPerEdge, Math.floor(Math.hypot(...sub(b, a)) / step));
+      for (let s = 1;s < n; s++)
+        out.push(lerp(a, b, s / n));
+    }
+    out.push(lerp(lerp(tri[0], tri[1], 0.5), tri[2], 1 / 3));
+  }
+  return out;
+}
+
+// src/qa/inside.ts
+var cellFor = (m) => {
+  const b = boundsOf2(m);
+  return Math.max(0.2, Math.hypot(b.max[0] - b.min[0], b.max[1] - b.min[1], b.max[2] - b.min[2]) / 256);
+};
+var NUDGE = [0.0000137, 0.0000291, 0.0000373];
+var OTHER = [
+  [1, 2],
+  [0, 2],
+  [0, 1]
+];
+
+class SolidIndex {
+  tri;
+  columns = [new Map, new Map, new Map];
+  cell;
+  constructor(mesh) {
+    this.cell = cellFor(mesh);
+    const CELL = this.cell;
+    const n = mesh.indices.length / 3;
+    this.tri = new Float64Array(n * 9);
+    for (let t = 0;t < n; t++) {
+      for (let v = 0;v < 3; v++) {
+        const idx = mesh.indices[t * 3 + v] ?? 0;
+        for (let k = 0;k < 3; k++)
+          this.tri[t * 9 + v * 3 + k] = mesh.positions[idx * 3 + k] ?? 0;
+      }
+      for (const axis of [0, 1, 2]) {
+        const [i, j] = OTHER[axis];
+        const T = this.tri;
+        const o = t * 9;
+        const a = T[o + i] ?? 0;
+        const b = T[o + 3 + i] ?? 0;
+        const c = T[o + 6 + i] ?? 0;
+        const d = T[o + j] ?? 0;
+        const e = T[o + 3 + j] ?? 0;
+        const f = T[o + 6 + j] ?? 0;
+        const u0 = Math.floor(Math.min(a, b, c) / CELL);
+        const u1 = Math.floor(Math.max(a, b, c) / CELL);
+        const v0 = Math.floor(Math.min(d, e, f) / CELL);
+        const v1 = Math.floor(Math.max(d, e, f) / CELL);
+        const map = this.columns[axis];
+        if (!map)
+          continue;
+        for (let u = u0;u <= u1; u++)
+          for (let v = v0;v <= v1; v++) {
+            const k = u * 92837111 ^ v * 689287499;
+            const list = map.get(k);
+            if (list)
+              list.push(t);
+            else
+              map.set(k, [t]);
+          }
+      }
+    }
+  }
+  parity(px, py, pz, axis) {
+    const [i, j] = OTHER[axis];
+    const p = [px, py, pz];
+    const pi = p[i] ?? 0;
+    const pj = p[j] ?? 0;
+    const pk = p[axis] ?? 0;
+    const CELL = this.cell;
+    const list = this.columns[axis]?.get(Math.floor(pi / CELL) * 92837111 ^ Math.floor(pj / CELL) * 689287499);
+    if (!list)
+      return false;
+    const T = this.tri;
+    let n = 0;
+    for (const t of list) {
+      const o = t * 9;
+      const ai = T[o + i] ?? 0;
+      const aj = T[o + j] ?? 0;
+      const bi = T[o + 3 + i] ?? 0;
+      const bj = T[o + 3 + j] ?? 0;
+      const ci = T[o + 6 + i] ?? 0;
+      const cj = T[o + 6 + j] ?? 0;
+      const area = (bi - ai) * (cj - aj) - (bj - aj) * (ci - ai);
+      if (Math.abs(area) < 0.00000000000001)
+        continue;
+      const w0 = ((bi - pi) * (cj - pj) - (bj - pj) * (ci - pi)) / area;
+      const w1 = ((ci - pi) * (aj - pj) - (cj - pj) * (ai - pi)) / area;
+      const w2 = 1 - w0 - w1;
+      if (w0 < 0 || w1 < 0 || w2 < 0)
+        continue;
+      const depth = w0 * (T[o + axis] ?? 0) + w1 * (T[o + 3 + axis] ?? 0) + w2 * (T[o + 6 + axis] ?? 0);
+      if (depth > pk)
+        n++;
+    }
+    return n % 2 === 1;
+  }
+  inside(point) {
+    const x = point[0] + NUDGE[0];
+    const y = point[1] + NUDGE[1];
+    const z = point[2] + NUDGE[2];
+    const vz = this.parity(x, y, z, 2);
+    const vy = this.parity(x, y, z, 1);
+    return vz === vy ? vz : this.parity(x, y, z, 0);
+  }
+}
+var insideSolid2 = (p, m) => new SolidIndex(m).inside(p);
+
+// src/qa/inspect.ts
+var glob2 = (pattern) => new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*").replaceAll("?", ".")}$`);
+function inspect2(asset) {
+  const world = worldMeshes2(asset.parts);
+  const parts = (sel) => [...world.keys()].filter((n) => glob2(sel).test(n));
+  const meshes = new Map;
+  const grids = new Map;
+  const solids = new Map;
+  const samples = new Map;
+  const mesh = (sel) => {
+    if (!meshes.has(sel)) {
+      const ms = parts(sel).flatMap((n) => world.get(n) ?? []);
+      meshes.set(sel, ms.length ? merge2(ms) : null);
+    }
+    return meshes.get(sel) ?? null;
+  };
+  const cached = (map, key, make) => {
+    const hit = map.get(key);
+    if (hit !== undefined)
+      return hit;
+    const v = make();
+    map.set(key, v);
+    return v;
+  };
+  const near = (a, b, eps) => [0, 1, 2].every((k) => (a.min[k] ?? 0) <= (b.max[k] ?? 0) + eps && (b.min[k] ?? 0) <= (a.max[k] ?? 0) + eps);
+  return {
+    asset,
+    parts,
+    mesh,
+    bounds: (sel) => {
+      const m = mesh(sel);
+      return m ? boundsOf2(m) : null;
+    },
+    distance(a, b, max = 1) {
+      const ma = mesh(a);
+      const mb = mesh(b);
+      if (!ma || !mb || !near(boundsOf2(ma), boundsOf2(mb), max))
+        return max;
+      const grid = cached(grids, b, () => new TriangleGrid2(mb));
+      const pts = cached(samples, a, () => surfaceSamples2(ma, 0.05, 8));
+      for (const r of [0.02, 0.1, 0.5, max].filter((x) => x <= max)) {
+        let best = Infinity;
+        for (const p of pts)
+          best = Math.min(best, grid.nearest(p, Math.min(r, best)));
+        if (best <= r)
+          return best;
+      }
+      return max;
+    },
+    penetration(a, b) {
+      const ma = mesh(a);
+      const mb = mesh(b);
+      if (!ma || !mb)
+        return { depth: 0, samples: 0 };
+      const bb = boundsOf2(mb);
+      if (!near(boundsOf2(ma), bb, 0))
+        return { depth: 0, samples: 0 };
+      const grid = cached(grids, b, () => new TriangleGrid2(mb));
+      const solid = cached(solids, b, () => new SolidIndex(mb));
+      let depth = 0;
+      let count = 0;
+      for (const p of cached(samples, `${a}#pen`, () => surfaceSamples2(ma, 0.1, 3))) {
+        if (!near({ min: p, max: p }, bb, 0) || !solid.inside(p))
+          continue;
+        count++;
+        depth = Math.max(depth, grid.nearest(p, 0.5));
+      }
+      return { depth, samples: count };
+    }
+  };
+}
+
+// src/qa/checks.ts
+var inspectors = new WeakMap;
+var inspectorFor = (asset) => {
+  const hit = inspectors.get(asset);
+  if (hit)
+    return hit;
+  const made = inspect2(asset);
+  inspectors.set(asset, made);
+  return made;
+};
+var CLASH = 0.01;
+var clear2 = (a, b, minGap = 0) => (asset) => {
+  const q = inspectorFor(asset);
+  const out = [];
+  for (const pa of q.parts(a)) {
+    for (const pb of q.parts(b)) {
+      if (pa === pb)
+        continue;
+      const pen = q.penetration(pa, pb);
+      if (pen.depth > CLASH) {
+        out.push({
+          part: pa,
+          message: `'${pa}' sinks ${(pen.depth * 100).toFixed(1)} cm into '${pb}'`,
+          fix: `move '${pa}' out of '${pb}' (or shrink one); they are declared clear of each other`
+        });
+      } else if (minGap > 0) {
+        const d = q.distance(pa, pb, minGap);
+        if (d < minGap)
+          out.push({
+            part: pa,
+            message: `'${pa}' is ${(d * 100).toFixed(1)} cm from '${pb}', needs ≥ ${minGap * 100} cm`,
+            fix: "open the gap — running clearance, mud, suspension travel"
+          });
+      }
+    }
+  }
+  return out;
+};
+var noOverlap2 = (selector) => (asset) => {
+  const names = inspectorFor(asset).parts(selector);
+  return names.flatMap((a, i) => names.slice(i + 1).flatMap((b) => clear2(a, b)(asset)));
+};
+var touches2 = (a, b, eps = 0.02) => (asset) => {
+  const q = inspectorFor(asset);
+  if (q.parts(a).length === 0 || q.parts(b).length === 0)
+    return [];
+  const d = q.distance(a, b, 1);
+  return d <= eps ? [] : [
+    {
+      part: a,
+      message: `'${a}' should touch '${b}' but is ${(d * 100).toFixed(1)} cm away`,
+      fix: `seat '${a}' on '${b}'`
+    }
+  ];
+};
+var symmetric2 = (left, right, axis = "y", tol = 0.02) => (asset) => {
+  const q = inspectorFor(asset);
+  const k = { x: 0, y: 1, z: 2 }[axis];
+  const token = new RegExp(`${left.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?=_|$)`);
+  return q.parts("*").filter((n) => token.test(n)).flatMap((l) => {
+    const r = l.replace(token, right);
+    const bl = q.bounds(l);
+    const br = q.bounds(r);
+    if (!bl || !br)
+      return [{ part: l, message: `'${l}' has no mirror '${r}'`, fix: `add '${r}' or rename` }];
+    const off = Math.abs(bl.min[k] + br.max[k]) + Math.abs(bl.max[k] + br.min[k]);
+    return off > tol * 2 ? [
+      {
+        part: l,
+        message: `'${l}' and '${r}' are not mirrored across ${axis}=0 (off by ${(off * 50).toFixed(1)} cm)`,
+        fix: "build one side and mirror it — place(mesh, { scale: [1, -1, 1] }) flips winding; prefer reusing the same builder with a sign"
+      }
+    ] : [];
+  });
+};
+var runChecks2 = (asset) => asset.checks.flatMap((c) => [...c(asset)]);
+// src/qa/types.ts
+var CONTACT_EPS2 = 0.02;
+var CLASH_EPS2 = 0.01;
+
+// src/qa/clash.ts
+var SLICES = 24;
+function subtree(parts, root) {
+  const out = new Set([root]);
+  for (const p of parts)
+    if (p.parent && out.has(p.parent))
+      out.add(p.name);
+  return out;
+}
+var BINS = 72;
+var TAU = Math.PI * 2;
+function spinVolume(mesh, pivot, axis, range) {
+  const len = Math.hypot(...axis) || 1;
+  const u = [axis[0] / len, axis[1] / len, axis[2] / len];
+  const ref = Math.abs(u[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const dotRef = ref[0] * u[0] + ref[1] * u[1] + ref[2] * u[2];
+  const e1raw = [ref[0] - dotRef * u[0], ref[1] - dotRef * u[1], ref[2] - dotRef * u[2]];
+  const e1l = Math.hypot(...e1raw) || 1;
+  const e1 = [e1raw[0] / e1l, e1raw[1] / e1l, e1raw[2] / e1l];
+  const e2 = [
+    u[1] * e1[2] - u[2] * e1[1],
+    u[2] * e1[0] - u[0] * e1[2],
+    u[0] * e1[1] - u[1] * e1[0]
+  ];
+  const coords = (p) => {
+    const d = [p[0] - pivot[0], p[1] - pivot[1], p[2] - pivot[2]];
+    const a = d[0] * u[0] + d[1] * u[1] + d[2] * u[2];
+    const x = d[0] * e1[0] + d[1] * e1[1] + d[2] * e1[2];
+    const y = d[0] * e2[0] + d[1] * e2[1] + d[2] * e2[2];
+    return [a, Math.hypot(x, y), Math.atan2(y, x)];
+  };
+  const bin = (phi) => Math.floor((phi % TAU + TAU) % TAU / (TAU / BINS)) % BINS;
+  const pts = surfaceSamples2(mesh, 0.05, 8).map(coords);
+  const lo = Math.min(...pts.map((p) => p[0]));
+  const hi = Math.max(...pts.map((p) => p[0]));
+  const span = Math.max(hi - lo, 0.000001);
+  const slice = (a) => Math.min(SLICES - 1, Math.floor((a - lo) / span * SLICES));
+  const radius = new Float64Array(SLICES * BINS).fill(-1);
+  for (const [a, r, phi] of pts) {
+    const k = slice(a) * BINS + bin(phi);
+    radius[k] = Math.max(radius[k] ?? -1, r);
+  }
+  const [from, to] = range ?? [0, TAU];
+  const steps = range ? Math.ceil((to - from) / (TAU / BINS)) + 2 : BINS;
+  const reach = Math.max(...radius) + Math.max(Math.abs(lo), Math.abs(hi));
+  return {
+    min: [pivot[0] - reach, pivot[1] - reach, pivot[2] - reach],
+    max: [pivot[0] + reach, pivot[1] + reach, pivot[2] + reach],
+    inside: (p) => {
+      const [a, r, phi] = coords(p);
+      if (a < lo + CLASH_EPS2 || a > hi - CLASH_EPS2)
+        return false;
+      const base = slice(a) * BINS;
+      for (let i = 0;i < Math.min(steps, BINS); i++) {
+        const theta = range ? from - TAU / BINS + i * (TAU / BINS) : i * (TAU / BINS);
+        if (r < (radius[base + bin(phi - theta)] ?? -1) - CLASH_EPS2)
+          return true;
+      }
+      return false;
+    }
+  };
+}
+function slideVolume(mesh, offset, oneWay = false) {
+  const b = boundsOf2(mesh);
+  const neg = (k) => oneWay ? Math.min(0, offset[k] ?? 0) : -Math.abs(offset[k] ?? 0);
+  const pos = (k) => oneWay ? Math.max(0, offset[k] ?? 0) : Math.abs(offset[k] ?? 0);
+  const lo = [0, 1, 2].map((k) => (b.min[k] ?? 0) + neg(k) + CLASH_EPS2);
+  const hi = [0, 1, 2].map((k) => (b.max[k] ?? 0) + pos(k) - CLASH_EPS2);
+  return {
+    min: [lo[0] ?? 0, lo[1] ?? 0, lo[2] ?? 0],
+    max: [hi[0] ?? 0, hi[1] ?? 0, hi[2] ?? 0],
+    inside: (p) => [0, 1, 2].every((k) => (p[k] ?? 0) > (lo[k] ?? 0) && (p[k] ?? 0) < (hi[k] ?? 0))
+  };
+}
+var inBox = (p, v) => p[0] >= v.min[0] && p[0] <= v.max[0] && p[1] >= v.min[1] && p[1] <= v.max[1] && p[2] >= v.min[2] && p[2] <= v.max[2];
+var clashes2 = (asset) => {
+  const meshes = worldMeshes2(asset.parts);
+  const xf = worldTransforms2(asset.parts);
+  const findings = [];
+  for (const root of asset.parts.filter((p) => p.motion)) {
+    const moving = subtree(asset.parts, root.name);
+    const body = merge2([...moving].flatMap((n) => meshes.get(n) ?? []));
+    const t = xf.get(root.name);
+    if (!t || body.indices.length === 0 || !root.motion)
+      continue;
+    const c = Math.cos(t.yaw);
+    const s = Math.sin(t.yaw);
+    const rot = (v) => [v[0] * c - v[1] * s, v[0] * s + v[1] * c, v[2]];
+    const m = root.motion;
+    const peak = m.kind === "sway" ? m.degrees * Math.PI / 180 : 0;
+    const vol = m.kind === "slide" ? slideVolume(body, rot(m.offset), m.oneWay) : m.kind === "sway" ? spinVolume(body, t.origin, rot(m.axis), m.oneWay ? [0, peak] : [-peak, peak]) : spinVolume(body, t.origin, rot(m.axis));
+    for (const [name, mesh] of meshes) {
+      if (moving.has(name) || root.clearOf?.includes(name))
+        continue;
+      const b = boundsOf2(mesh);
+      if (!inBox(b.min, {
+        ...vol,
+        min: [
+          vol.min[0] - (b.max[0] - b.min[0]),
+          vol.min[1] - (b.max[1] - b.min[1]),
+          vol.min[2] - (b.max[2] - b.min[2])
+        ]
+      }))
+        continue;
+      const hits = surfaceSamples2(mesh, 0.1, 4).filter((p) => inBox(p, vol) && vol.inside(p)).length;
+      if (hits > 0) {
+        findings.push({
+          gate: "clashes",
+          part: name,
+          message: `'${name}' cuts into the swept ${root.motion.kind} of '${root.name}' (${hits} sample${hits === 1 ? "" : "s"} deeper than ${CLASH_EPS2 * 100} cm)`,
+          fix: `move/trim '${name}' or '${root.name}' for running clearance; if they are meant to interlock (an axle through its bearing), list it: clearOf: ['${name}'] on '${root.name}'`
+        });
+      }
+    }
+  }
+  return findings;
+};
+// src/qa/floating.ts
+var near = (a, b, eps) => [0, 1, 2].every((k) => (a.min[k] ?? 0) <= (b.max[k] ?? 0) + eps && (b.min[k] ?? 0) <= (a.max[k] ?? 0) + eps);
+function touching2(a, b, grid, eps = CONTACT_EPS2) {
+  const bb = boundsOf2(b);
+  for (const p of surfaceSamples2(a, 0.1, 4)) {
+    if (!near({ min: p, max: p }, bb, eps))
+      continue;
+    if (grid.nearest(p, eps) <= eps)
+      return true;
+  }
+  return false;
+}
+var floatingParts2 = (asset) => {
+  const meshes = [...worldMeshes2(asset.parts)];
+  const bounds = new Map(meshes.map(([n, m]) => [n, boundsOf2(m)]));
+  const grids = new Map;
+  const grid = (n, m) => {
+    const g = grids.get(n) ?? new TriangleGrid2(m);
+    grids.set(n, g);
+    return g;
+  };
+  const grounded = new Set(meshes.filter(([n]) => (bounds.get(n)?.min[2] ?? 1) <= CONTACT_EPS2).map(([n]) => n));
+  const frontier = [...grounded];
+  while (frontier.length > 0) {
+    const g = frontier.pop() ?? "";
+    const gm = meshes.find(([n]) => n === g)?.[1];
+    const gb = bounds.get(g);
+    if (!gm || !gb)
+      continue;
+    for (const [n, m] of meshes) {
+      const b = bounds.get(n);
+      if (grounded.has(n) || !b || !near(b, gb, CONTACT_EPS2))
+        continue;
+      if (touching2(m, gm, grid(g, gm)) || touching2(gm, m, grid(n, m))) {
+        grounded.add(n);
+        frontier.push(n);
+      }
+    }
+  }
+  return meshes.filter(([n]) => !grounded.has(n)).map(([n]) => ({
+    gate: "floating-parts",
+    part: n,
+    message: `'${n}' has no surface within ${CONTACT_EPS2 * 100} cm of anything attached to the ground`,
+    fix: "move it onto what holds it (check `at`, parent and the LOD-gated detail around it) — bounding boxes touching is not enough"
+  }));
+};
+// src/qa/measures.ts
+var AXIS = { x: 0, y: 1, z: 2 };
+function union(bounds) {
+  if (bounds.length === 0)
+    return null;
+  const k = [0, 1, 2];
+  return {
+    min: k.map((i) => Math.min(...bounds.map((b) => b.min[i]))),
+    max: k.map((i) => Math.max(...bounds.map((b) => b.max[i])))
+  };
+}
+function measure2(asset, m) {
+  const meshes = worldMeshes2(asset.parts);
+  const of = (prefix) => union([...meshes].filter(([n]) => n === prefix || n.startsWith(`${prefix}_`)).map(([, mesh]) => boundsOf2(mesh)));
+  const k = AXIS[m.axis];
+  if (m.between) {
+    const [a, b] = [of(m.between[0]), of(m.between[1])];
+    if (!a || !b)
+      return null;
+    return Math.abs((a.min[k] + a.max[k]) / 2 - (b.min[k] + b.max[k]) / 2);
+  }
+  const u = union((m.parts ?? []).map(of).filter((b) => b !== null));
+  return u ? u.max[k] - u.min[k] : null;
+}
+var measures2 = (asset) => {
+  if (asset.lod !== 0 || !asset.real?.measures)
+    return [];
+  return asset.real.measures.flatMap((m) => {
+    const got = measure2(asset, m);
+    const tol = m.tolerance ?? 0.02;
+    if (got === null) {
+      return [
+        {
+          gate: "measures",
+          message: `'${m.label}': no part matches ${JSON.stringify(m.parts ?? m.between)}`,
+          fix: "name the parts the measure refers to, or fix the names in the measure"
+        }
+      ];
+    }
+    return Math.abs(got - m.value) / m.value > tol ? [
+      {
+        gate: "measures",
+        message: `${m.label}: ${got.toFixed(3)} m on ${m.axis.toUpperCase()}, spec ${m.value} m (±${tol * 100}%)${m.source ? ` — ${m.source}` : ""}`,
+        fix: "rebuild the part from the spec number; never edit the spec to match the model"
+      }
+    ] : [];
+  });
+};
+
+// src/qa/occlusion.ts
+var overlaps = (a, b, eps) => [0, 1, 2].every((k) => (a.min[k] ?? 0) <= (b.max[k] ?? 0) + eps && (b.min[k] ?? 0) <= (a.max[k] ?? 0) + eps);
+var contains = (outer, inner) => [0, 1, 2].every((k) => (outer.min[k] ?? 0) <= (inner.min[k] ?? 0) && (inner.max[k] ?? 0) <= (outer.max[k] ?? 0));
+function faceSamples(m, cap) {
+  const tris = m.indices.length / 3;
+  const step = Math.max(1, Math.floor(tris / cap));
+  const out = [];
+  const P = m.positions;
+  const v = (i) => [P[i * 3] ?? 0, P[i * 3 + 1] ?? 0, P[i * 3 + 2] ?? 0];
+  for (let t = 0;t < tris; t += step) {
+    const a = v(m.indices[t * 3] ?? 0);
+    const b = v(m.indices[t * 3 + 1] ?? 0);
+    const c = v(m.indices[t * 3 + 2] ?? 0);
+    const u = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const w = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const g = [
+      u[1] * w[2] - u[2] * w[1],
+      u[2] * w[0] - u[0] * w[2],
+      u[0] * w[1] - u[1] * w[0]
+    ];
+    const len = Math.hypot(...g);
+    if (len < 0.0000000001)
+      continue;
+    out.push({
+      p: [(a[0] + b[0] + c[0]) / 3, (a[1] + b[1] + c[1]) / 3, (a[2] + b[2] + c[2]) / 3],
+      n: [g[0] / len, g[1] / len, g[2] / len]
+    });
+  }
+  return out;
+}
+function scene(asset) {
+  const mesh = worldMeshes2(asset.parts);
+  const bounds = new Map([...mesh].map(([n, m]) => [n, boundsOf2(m)]));
+  const grids = new Map;
+  const solids = new Map;
+  const lazy = (cache, make) => (name) => {
+    const hit = cache.get(name);
+    if (hit)
+      return hit;
+    const made = make(mesh.get(name) ?? {
+      positions: new Float32Array,
+      normals: new Float32Array,
+      uvs: new Float32Array,
+      colors: new Float32Array,
+      indices: new Uint32Array
+    });
+    cache.set(name, made);
+    return made;
+  };
+  return {
+    names: [...mesh.keys()],
+    mesh,
+    bounds,
+    grid: lazy(grids, (m) => new TriangleGrid2(m)),
+    solid: lazy(solids, (m) => new SolidIndex(m))
+  };
+}
+var ON = 0.0002;
+var PROBE = 0.002;
+var zFighting2 = (asset) => {
+  const s = scene(asset);
+  const out = [];
+  for (const a of s.names) {
+    const ba = s.bounds.get(a);
+    const ma = s.mesh.get(a);
+    if (!ba || !ma)
+      continue;
+    const samples = faceSamples(ma, 256);
+    for (const b of s.names) {
+      const bb = s.bounds.get(b);
+      if (a === b || !bb || !overlaps(ba, bb, ON))
+        continue;
+      let hits = 0;
+      for (const { p, n } of samples) {
+        if (!overlaps({ min: p, max: p }, bb, ON) || s.grid(b).nearest(p, ON) > ON)
+          continue;
+        const solid = s.solid(b);
+        const behind = solid.inside([
+          p[0] - n[0] * PROBE,
+          p[1] - n[1] * PROBE,
+          p[2] - n[2] * PROBE
+        ]);
+        const front = solid.inside([p[0] + n[0] * PROBE, p[1] + n[1] * PROBE, p[2] + n[2] * PROBE]);
+        if (behind && !front)
+          hits++;
+      }
+      if (hits >= 2)
+        out.push({
+          gate: "z-fighting",
+          part: a,
+          message: `'${a}' has ${hits} face sample(s) lying in '${b}''s surface, facing the same way — it flickers`,
+          fix: `stand '${a}' proud of '${b}' by ≥ 2 mm, or inset it, or cut it from '${b}'; coplanar faces never render cleanly`
+        });
+    }
+  }
+  return out;
+};
+var hiddenParts2 = (asset) => {
+  const s = scene(asset);
+  return s.names.flatMap((a) => {
+    const ba = s.bounds.get(a);
+    const ma = s.mesh.get(a);
+    if (!ba || !ma)
+      return [];
+    const pts = faceSamples(ma, 64).map((x) => x.p);
+    const stride = Math.max(1, Math.floor(ma.positions.length / 192));
+    for (let i = 0;i < ma.positions.length / 3; i += stride)
+      pts.push([
+        ma.positions[i * 3] ?? 0,
+        ma.positions[i * 3 + 1] ?? 0,
+        ma.positions[i * 3 + 2] ?? 0
+      ]);
+    const host = s.names.find((b) => {
+      const bb = s.bounds.get(b);
+      if (b === a || !bb || !contains(bb, ba))
+        return false;
+      return pts.every((p) => s.solid(b).inside(p)) && pts.every((p) => s.grid(b).nearest(p, PROBE) > PROBE);
+    });
+    return host ? [
+      {
+        gate: "hidden-parts",
+        part: a,
+        message: `'${a}' (${ma.indices.length / 3} tris) is entirely inside '${host}' — nobody can see it`,
+        fix: `delete it, gate it behind ctx.lod, or move it out of '${host}'; hidden triangles are wasted budget`
+      }
+    ] : [];
+  });
+};
+
+// src/qa/sanity.ts
+var parts = (asset) => asset.parts.flatMap((p) => p.mesh ? [[p, p.mesh]] : []);
+var finite = (a) => {
+  for (let i = 0;i < a.length; i++)
+    if (!Number.isFinite(a[i] ?? 0))
+      return false;
+  return true;
+};
+var nonFinite2 = (asset) => parts(asset).flatMap(([p, m]) => {
+  const bad = [
+    ["positions", m.positions],
+    ["normals", m.normals],
+    ["uvs", m.uvs],
+    ["colors", m.colors]
+  ].filter(([, a]) => !finite(a)).map(([n]) => n);
+  const maxIndex = m.positions.length / 3;
+  const outOfRange = m.indices.some((i) => i >= maxIndex);
+  if (outOfRange)
+    bad.push("indices");
+  return bad.length ? [
+    {
+      gate: "non-finite",
+      part: p.name,
+      message: `'${p.name}' has NaN/Infinity or out-of-range data in ${bad.join(", ")}`,
+      fix: "look for a zero-length normalize, a divide by a zero count or segment, or an index past the vertex count"
+    }
+  ] : [];
+});
+var vertexColors2 = (asset) => parts(asset).flatMap(([p, m]) => {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const c of m.colors) {
+    if (c < lo)
+      lo = c;
+    if (c > hi)
+      hi = c;
+  }
+  return lo < -0.000001 || hi > 1 + 0.000001 ? [
+    {
+      gate: "vertex-colors",
+      part: p.name,
+      message: `'${p.name}' vertex colour spans ${lo.toFixed(3)}…${hi.toFixed(3)}, outside linear [0,1]`,
+      fix: "colours are linear 0–1 (use the palette / material helpers); clamp after grime or livery maths"
+    }
+  ] : [];
+});
+function windingStats(m) {
+  const P = m.positions;
+  const N = m.normals;
+  let flipped = 0;
+  let area = 0;
+  let flippedArea = 0;
+  let counted = 0;
+  for (let t = 0;t < m.indices.length; t += 3) {
+    const a = (m.indices[t] ?? 0) * 3;
+    const b = (m.indices[t + 1] ?? 0) * 3;
+    const c = (m.indices[t + 2] ?? 0) * 3;
+    const ux = (P[b] ?? 0) - (P[a] ?? 0);
+    const uy = (P[b + 1] ?? 0) - (P[a + 1] ?? 0);
+    const uz = (P[b + 2] ?? 0) - (P[a + 2] ?? 0);
+    const vx = (P[c] ?? 0) - (P[a] ?? 0);
+    const vy = (P[c + 1] ?? 0) - (P[a + 1] ?? 0);
+    const vz = (P[c + 2] ?? 0) - (P[a + 2] ?? 0);
+    const gx = uy * vz - uz * vy;
+    const gy = uz * vx - ux * vz;
+    const gz = ux * vy - uy * vx;
+    const len = Math.hypot(gx, gy, gz);
+    if (len < 0.000000000001)
+      continue;
+    counted++;
+    const nx = (N[a] ?? 0) + (N[b] ?? 0) + (N[c] ?? 0);
+    const ny = (N[a + 1] ?? 0) + (N[b + 1] ?? 0) + (N[c + 1] ?? 0);
+    const nz = (N[a + 2] ?? 0) + (N[b + 2] ?? 0) + (N[c + 2] ?? 0);
+    area += len;
+    if ((gx * nx + gy * ny + gz * nz) / (len * (Math.hypot(nx, ny, nz) || 1)) < -0.1) {
+      flipped++;
+      flippedArea += len;
+    }
+  }
+  return { flipped, area, flippedArea, counted };
+}
+var normalsMatchWinding2 = (asset) => parts(asset).flatMap(([p, m]) => {
+  const s = windingStats(m);
+  return s.flipped > 0 && s.flippedArea > s.area * 0.01 ? [
+    {
+      gate: "normals-winding",
+      part: p.name,
+      message: `'${p.name}': ${s.flipped} triangle(s) (${(100 * s.flippedArea / s.area).toFixed(1)}% of its area) have vertex normals opposing their face — inverted winding, or normals smoothed across a hard crease`,
+      fix: "split normals at creases (lathe crease angle / weightedNormals hardAngle), or fix the mirrored piece: a negative-scale place() flips winding but not normals"
+    }
+  ] : [];
+});
+var degenerateTriangles2 = (asset) => parts(asset).flatMap(([p, m]) => {
+  const tris = m.indices.length / 3;
+  const zero = tris - windingStats(m).counted;
+  return zero > tris * 0.05 ? [
+    {
+      gate: "degenerate-triangles",
+      part: p.name,
+      message: `'${p.name}': ${zero} of ${tris} triangles have zero area`,
+      fix: "a ring/lathe with a zero radius emits fans of slivers: cap it with a point instead, or skip the segment"
+    }
+  ] : [];
+});
+
+// src/qa/gates.ts
+var worldBounds = (asset) => {
+  const xf = worldTransforms2(asset.parts);
+  const out = new Map;
+  for (const p of asset.parts) {
+    const t = xf.get(p.name);
+    if (!t || !p.mesh || p.mesh.indices.length === 0)
+      continue;
+    const b = boundsOf2(p.mesh);
+    const corners = [0, 1, 2, 3, 4, 5, 6, 7].map((i) => toWorld2(t, [
+      i & 1 ? b.max[0] : b.min[0],
+      i & 2 ? b.max[1] : b.min[1],
+      i & 4 ? b.max[2] : b.min[2]
+    ]));
+    const axis = (k, f) => f(...corners.map((c) => c[k]));
+    out.set(p.name, {
+      min: [axis(0, Math.min), axis(1, Math.min), axis(2, Math.min)],
+      max: [axis(0, Math.max), axis(1, Math.max), axis(2, Math.max)]
+    });
+  }
+  return out;
+};
+var triangleBudget2 = (asset) => {
+  const tris = asset.parts.reduce((s, p) => s + (p.mesh ? triangleCount2(p.mesh) : 0), 0);
+  const cap = asset.budget.triangles[asset.lod];
+  return tris > cap ? [
+    {
+      gate: "triangle-budget",
+      message: `LOD${asset.lod} has ${tris} triangles, budget ${cap}`,
+      fix: "drop detail at this LOD (read ctx.lod) or raise the budget with a reason"
+    }
+  ] : [];
+};
+var partNames2 = (asset) => asset.parts.filter((p) => !/^[a-z][a-z0-9_]*$/.test(p.name)).map((p) => ({
+  gate: "part-names",
+  part: p.name,
+  message: `part '${p.name}' is not snake_case`,
+  fix: "rename it — engines bind to node names like axle_0, door_l"
+}));
+var proportions2 = (asset) => {
+  const real = asset.real;
+  if (!real || asset.lod !== 0)
+    return [];
+  const boxes = [...worldBounds(asset).values()];
+  const span = (k) => Math.max(...boxes.map((b) => b.max[k])) - Math.min(...boxes.map((b) => b.min[k]));
+  const tol = real.tolerance ?? 0.05;
+  return [
+    ["length", 0, real.length],
+    ["width", 1, real.width],
+    ["height", 2, real.height]
+  ].flatMap(([axis, k, want]) => {
+    const got = span(k);
+    return Math.abs(got - want) / want > tol ? [
+      {
+        gate: "proportions",
+        message: `${axis} ${got.toFixed(2)} m vs real ${want} m (±${tol * 100}%)`,
+        fix: `rescale along ${"XYZ"[k]} — re-derive the lengths from the sources, don't fudge the tolerance`
+      }
+    ] : [];
+  });
+};
+var silhouetteIoU2 = (_asset, _referencePng) => notImplemented2("silhouette IoU gate");
+var recipeChecks = (asset) => runChecks2(asset).map((f) => ({
+  gate: "check",
+  ...f.part ? { part: f.part } : {},
+  message: f.message,
+  fix: f.fix
+}));
+var DEFAULT_GATES2 = [
+  triangleBudget2,
+  floatingParts2,
+  clashes2,
+  partNames2,
+  proportions2,
+  measures2,
+  recipeChecks,
+  nonFinite2,
+  vertexColors2,
+  hiddenParts2,
+  normalsMatchWinding2
+];
+function runQa2(asset, gates = DEFAULT_GATES2) {
+  return gates.flatMap((g) => g(asset));
+}
+// src/qa/lods.ts
+var tris = (a) => a.parts.reduce((s, p) => s + (p.mesh ? p.mesh.indices.length / 3 : 0), 0);
+var lodTriangles2 = (lods) => lods.slice(1).flatMap((a, i) => {
+  const prev = lods[i];
+  if (!prev || tris(a) <= tris(prev))
+    return [];
+  return [
+    {
+      gate: "lod-triangles",
+      message: `LOD${a.lod} has ${tris(a)} triangles, more than LOD${prev.lod} (${tris(prev)})`,
+      fix: "each LOD must be cheaper than the one before: read ctx.lod / ctx.pick([...]) and drop segments or detail parts"
+    }
+  ];
+});
+function assetBounds(a) {
+  const all = [...worldMeshes2(a.parts).values()].map(boundsOf2);
+  if (all.length === 0)
+    return null;
+  const k = [0, 1, 2];
+  const lo = k.map((i) => Math.min(...all.map((b) => b.min[i])));
+  const hi = k.map((i) => Math.max(...all.map((b) => b.max[i])));
+  return {
+    min: [lo[0] ?? 0, lo[1] ?? 0, lo[2] ?? 0],
+    max: [hi[0] ?? 0, hi[1] ?? 0, hi[2] ?? 0]
+  };
+}
+var lodSilhouette2 = (tol = 0.05) => (lods) => {
+  const ref = lods[0] ? assetBounds(lods[0]) : null;
+  if (!ref)
+    return [];
+  return lods.slice(1).flatMap((a) => {
+    const b = assetBounds(a);
+    if (!b)
+      return [];
+    const off = [0, 1, 2].flatMap((k) => {
+      const lim = Math.max(0.05, (ref.max[k] - ref.min[k]) * tol);
+      const d = Math.max(Math.abs(b.min[k] - ref.min[k]), Math.abs(b.max[k] - ref.max[k]));
+      return d > lim ? [`${"XYZ"[k]} by ${(d * 100).toFixed(0)} cm`] : [];
+    });
+    return off.length ? [
+      {
+        gate: "lod-silhouette",
+        message: `LOD${a.lod} outline differs from LOD0 on ${off.join(", ")} — it will pop on LOD switch`,
+        fix: "keep the big masses at every LOD (drop detail, not extent): a far LOD is the same shape with fewer segments"
+      }
+    ] : [];
+  });
+};
+var pivots = (a) => a.parts.filter((p) => p.mesh === null || p.motion !== null).map((p) => p.name);
+var lodPivots2 = (lods) => {
+  const ref = lods[0];
+  if (!ref)
+    return [];
+  const want = pivots(ref);
+  return lods.slice(1).flatMap((a) => {
+    const have = new Set(a.parts.map((p) => p.name));
+    const missing = want.filter((n) => !have.has(n));
+    return missing.length ? [
+      {
+        gate: "lod-pivots",
+        message: `LOD${a.lod} drops pivot(s) ${missing.slice(0, 6).join(", ")}${missing.length > 6 ? ` (+${missing.length - 6})` : ""} that LOD0 has — game code driving them breaks at that LOD`,
+        fix: "keep the group/moving part at every LOD and gate only its geometry: ctx.group(name) always, detail meshes behind ctx.lod"
+      }
+    ] : [];
+  });
+};
+var DEFAULT_LOD_GATES2 = [lodTriangles2];
+function runLodQa2(lods, gates = DEFAULT_LOD_GATES2) {
+  return gates.flatMap((g) => g(lods));
+}
+export { pointTriangleDistance2, TriangleGrid2, surfaceSamples2, insideSolid2, glob2, inspect2, clear2, noOverlap2, touches2, symmetric2, runChecks2, CONTACT_EPS2, CLASH_EPS2, clashes2, touching2, floatingParts2, measure2, measures2, zFighting2, hiddenParts2, nonFinite2, vertexColors2, normalsMatchWinding2, degenerateTriangles2, triangleBudget2, partNames2, proportions2, silhouetteIoU2, DEFAULT_GATES2, runQa2, lodTriangles2, lodSilhouette2, lodPivots2, DEFAULT_LOD_GATES2, runLodQa2 };
+
+//# debugId=D719F42A62E0985B64756E2164756E21
+//# sourceMappingURL=chunk-jq4e17tj.js.map