codesynapt 0.0.0

package/scripts/competitor-watch.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// Competitor monitoring — fetch the latest releases and issues from
+// every repo listed in docs/COMPETITOR-WATCH.md and write a digest
+// to docs/competitor-log.md. Run weekly.
+//
+// Uses the public GitHub API (no token required for low-rate usage).
+// If GITHUB_TOKEN is set, it's used to lift the 60/h anon rate limit.
+//
+// Usage:
+//   node scripts/competitor-watch.mjs                  # default cadence
+//   node scripts/competitor-watch.mjs --since 14d      # last 14 days only
+//   node scripts/competitor-watch.mjs --repo codegraph # just one repo
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+const REPOS = [
+  { owner: 'colbymchenry',   name: 'codegraph',     cadence: 'weekly',     why: 'direct competitor' },
+  { owner: 'sourcegraph',    name: 'sourcegraph',   cadence: 'biweekly',   why: 'SCIP/LSIF gold standard' },
+  { owner: 'sourcegraph',    name: 'scip',          cadence: 'monthly',    why: 'symbol-index format' },
+  { owner: 'continuedev',    name: 'continue',      cadence: 'monthly',    why: 'open-source AI agent' },
+  { owner: 'Aider-AI',       name: 'aider',         cadence: 'monthly',    why: 'repo-map analogue' },
+  { owner: 'modelcontextprotocol', name: 'servers', cadence: 'monthly',    why: 'MCP spec drift' },
+  { owner: 'anthropics',     name: 'claude-code',   cadence: 'weekly',     why: 'primary client' },
+  { owner: 'tree-sitter',    name: 'tree-sitter',   cadence: 'biweekly',   why: 'parser ABI' },
+]
+
+const args = process.argv.slice(2)
+const getArg = (k) => { const i = args.indexOf(k); return i >= 0 ? args[i + 1] : null }
+const sinceArg = getArg('--since') || '7d'
+const repoFilter = getArg('--repo')
+
+const sinceMs = (() => {
+  const m = sinceArg.match(/^(\d+)([dhw])$/)
+  if (!m) return 7 * 86400_000
+  const n = parseInt(m[1], 10)
+  return { d: 86400_000, h: 3600_000, w: 7 * 86400_000 }[m[2]] * n
+})()
+const sinceDate = new Date(Date.now() - sinceMs)
+const sinceIso = sinceDate.toISOString()
+
+const TOKEN = process.env.GITHUB_TOKEN
+const HEADERS = {
+  'Accept': 'application/vnd.github+json',
+  'User-Agent': 'codesynapt-competitor-watch',
+  ...(TOKEN ? { 'Authorization': `Bearer ${TOKEN}` } : {}),
+}
+
+async function gh(pathPart) {
+  const url = `https://api.github.com${pathPart}`
+  const res = await fetch(url, { headers: HEADERS })
+  if (res.status === 403) {
+    const remaining = res.headers.get('x-ratelimit-remaining')
+    if (remaining === '0') {
+      console.error(`[rate-limit] hit; set GITHUB_TOKEN to lift to 5000/h`)
+      return null
+    }
+  }
+  if (!res.ok) {
+    console.error(`[gh] ${pathPart} → ${res.status}`)
+    return null
+  }
+  return res.json()
+}
+
+async function fetchRepo(repo) {
+  const base = `/repos/${repo.owner}/${repo.name}`
+  const [releases, issues, commits] = await Promise.all([
+    gh(`${base}/releases?per_page=5`),
+    gh(`${base}/issues?state=all&sort=updated&since=${sinceIso}&per_page=10`),
+    gh(`${base}/commits?since=${sinceIso}&per_page=10`),
+  ])
+  return {
+    repo,
+    releases: (releases || []).filter((r) => new Date(r.published_at) > sinceDate),
+    issues:   (issues   || []).filter((i) => !i.pull_request),
+    prs:      (issues   || []).filter((i) => i.pull_request),
+    commits:  (commits  || []).slice(0, 5),
+  }
+}
+
+function fmtDate(s) { return s ? s.split('T')[0] : '' }
+
+function repoSection(r) {
+  const lines = []
+  lines.push(`### [${r.repo.owner}/${r.repo.name}](https://github.com/${r.repo.owner}/${r.repo.name}) — _${r.repo.why}_`)
+  if (r.releases.length) {
+    lines.push(`\n**Releases (${r.releases.length})**`)
+    for (const rel of r.releases) {
+      lines.push(`- [\`${rel.tag_name}\`](${rel.html_url}) — ${fmtDate(rel.published_at)} · ${(rel.name || '').slice(0, 80)}`)
+    }
+  }
+  if (r.prs.length) {
+    lines.push(`\n**PRs (${r.prs.length} updated since ${sinceArg})**`)
+    for (const pr of r.prs.slice(0, 5)) {
+      lines.push(`- [#${pr.number}](${pr.html_url}) ${pr.state} · ${pr.title.slice(0, 100)}`)
+    }
+  }
+  if (r.issues.length) {
+    lines.push(`\n**Issues (${r.issues.length} updated since ${sinceArg})**`)
+    for (const iss of r.issues.slice(0, 5)) {
+      lines.push(`- [#${iss.number}](${iss.html_url}) ${iss.state} · ${iss.title.slice(0, 100)}`)
+    }
+  }
+  if (!r.releases.length && !r.issues.length && !r.prs.length) {
+    lines.push(`\n_no activity since ${sinceArg}_`)
+  }
+  return lines.join('\n')
+}
+
+async function main() {
+  const targets = repoFilter
+    ? REPOS.filter((r) => r.name === repoFilter)
+    : REPOS
+  if (!targets.length) {
+    console.error(`No repo matches "${repoFilter}". Available: ${REPOS.map((r) => r.name).join(', ')}`)
+    process.exit(1)
+  }
+  console.log(`[watch] fetching ${targets.length} repos, since ${sinceIso}`)
+  const results = []
+  for (const r of targets) {
+    process.stdout.write(`  ${r.owner}/${r.name}… `)
+    const out = await fetchRepo(r)
+    results.push(out)
+    console.log(`${out.releases.length}r ${out.prs.length}p ${out.issues.length}i`)
+  }
+  const today = new Date().toISOString().split('T')[0]
+  const md = [
+    `## ${today} — last ${sinceArg}`,
+    '',
+    ...results.map(repoSection).map((s) => s + '\n'),
+    '\n---\n',
+  ].join('\n')
+
+  // Prepend to docs/competitor-log.md so the newest entry is on top.
+  const logPath = path.resolve('docs', 'competitor-log.md')
+  let existing = ''
+  try { existing = await fs.readFile(logPath, 'utf8') } catch {}
+  const header = existing.startsWith('# ') ? '' : '# Competitor activity log\n\n'
+  await fs.writeFile(logPath, header + md + existing.replace(/^# Competitor activity log\n\n/, ''))
+  console.log(`\nWrote ${logPath}`)
+}
+
+main().catch((e) => { console.error(e); process.exit(1) })

package/scripts/copy-vendor.js

@@ -0,0 +1,21 @@
+// Copy three.module.js from node_modules into public/vendor/
+// so it can be loaded via a relative path in both browser and Electron modes.
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const ROOT = path.resolve(__dirname, '..')
+
+const src = path.join(ROOT, 'node_modules/three/build/three.module.js')
+const dst = path.join(ROOT, 'public/vendor/three.module.js')
+
+if (!fs.existsSync(src)) {
+  console.warn('[copy-vendor] three not installed yet — skipping')
+  process.exit(0)
+}
+
+fs.mkdirSync(path.dirname(dst), { recursive: true })
+fs.copyFileSync(src, dst)
+const size = (fs.statSync(dst).size / 1024).toFixed(0)
+console.log(`[copy-vendor] three.module.js → public/vendor/ (${size} KB)`)

package/scripts/download-bundled-node.cjs

@@ -0,0 +1,53 @@
+// Downloads Node 22 LTS Windows x64 binary into build/bundled-node/
+// so electron-builder can bundle it into the NSIS installer.
+//
+// Run before `npm run dist:win` if you want the offline installer
+// option to include a bundled Node. Skipped otherwise — the installer
+// just relies on the user's system Node.
+//
+// Usage: node scripts/download-bundled-node.cjs
+const fs = require('fs')
+const path = require('path')
+const https = require('https')
+
+const NODE_VERSION = 'v22.11.0'
+const URL = `https://nodejs.org/dist/${NODE_VERSION}/win-x64/node.exe`
+const OUT_DIR = path.resolve(__dirname, '..', 'build', 'bundled-node')
+const OUT_FILE = path.join(OUT_DIR, 'node.exe')
+
+if (fs.existsSync(OUT_FILE)) {
+  const size = fs.statSync(OUT_FILE).size
+  if (size > 50 * 1024 * 1024) {
+    console.log(`[bundled-node] already present (${(size/1024/1024).toFixed(1)} MB) — skipping`)
+    process.exit(0)
+  }
+}
+
+fs.mkdirSync(OUT_DIR, { recursive: true })
+
+console.log(`[bundled-node] downloading ${URL}`)
+const file = fs.createWriteStream(OUT_FILE)
+function fetch(url) {
+  https.get(url, (res) => {
+    if (res.statusCode === 301 || res.statusCode === 302) {
+      file.close()
+      fs.unlinkSync(OUT_FILE)
+      return fetch(res.headers.location)
+    }
+    if (res.statusCode !== 200) {
+      console.error(`[bundled-node] HTTP ${res.statusCode}`)
+      process.exit(1)
+    }
+    res.pipe(file)
+    file.on('finish', () => {
+      file.close()
+      const size = fs.statSync(OUT_FILE).size
+      console.log(`[bundled-node] downloaded ${(size/1024/1024).toFixed(1)} MB → ${OUT_FILE}`)
+    })
+  }).on('error', (e) => {
+    console.error(`[bundled-node] error: ${e.message}`)
+    fs.unlinkSync(OUT_FILE)
+    process.exit(1)
+  })
+}
+fetch(URL)

package/scripts/fuses-after-pack.cjs

@@ -0,0 +1,34 @@
+// Electron Fuses — flip security-relevant flags off in the packaged binary.
+// Called via package.json `build.afterPack` hook by electron-builder.
+//
+// Why: a signed Electron binary by default lets `ELECTRON_RUN_AS_NODE=1`
+// run arbitrary Node code. Closing that fuse removes that RCE vector.
+//
+// docs: https://www.electronjs.org/docs/latest/tutorial/fuses
+const path = require('path')
+const fs = require('fs')
+
+exports.default = async function fusesAfterPack(context) {
+  // @electron/fuses is ESM-only, so dynamic import from this CJS hook.
+  const { flipFuses, FuseVersion, FuseV1Options } = await import('@electron/fuses')
+  const exeName = context.packager.platform.nodeName === 'darwin'
+    ? `${context.packager.appInfo.productFilename}.app`
+    : `${context.packager.appInfo.productFilename}.exe`
+  const exePath = path.join(context.appOutDir, exeName)
+  if (!fs.existsSync(exePath)) {
+    console.warn(`[fuses] target not found: ${exePath} — skipping`)
+    return
+  }
+  await flipFuses(exePath, {
+    version: FuseVersion.V1,
+    [FuseV1Options.RunAsNode]: false,
+    [FuseV1Options.EnableCookieEncryption]: true,
+    [FuseV1Options.EnableNodeOptionsEnvironmentVariable]: false,
+    [FuseV1Options.EnableNodeCliInspectArguments]: false,
+    [FuseV1Options.EnableEmbeddedAsarIntegrityValidation]: false,
+    [FuseV1Options.OnlyLoadAppFromAsar]: false,
+    [FuseV1Options.LoadBrowserProcessSpecificV8Snapshot]: false,
+    [FuseV1Options.GrantFileProtocolExtraPrivileges]: false,
+  })
+  console.log(`[fuses] applied to ${exePath}`)
+}

package/scripts/license-check.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// License compliance check.
+// Walks node_modules, reads each package's license field, and fails
+// if any dependency uses a license outside the allowed list.
+//
+// Run via `npm run license-check`.
+//
+// Allowed licenses are the standard permissive set. GPL, AGPL, LGPL,
+// CC-BY-NC, and other copyleft / restrictive licenses are blocked
+// to avoid surprises in a project intended for MIT distribution.
+
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const ROOT = path.resolve(__dirname, '..')
+const MODULES = path.join(ROOT, 'node_modules')
+
+const ALLOWED = new Set([
+  'MIT',
+  'Apache-2.0',
+  'BSD',
+  'BSD-2-Clause',
+  'BSD-3-Clause',
+  'BSD-3-Clause-Clear',
+  'ISC',
+  'CC0-1.0',
+  '0BSD',
+  'Unlicense',
+  'WTFPL',
+  'Python-2.0',           // some Python-related tools
+  'BlueOak-1.0.0',
+  'Zlib',
+])
+
+// Some packages bundle both — we accept if any constituent is allowed.
+function isAllowedLicense(raw) {
+  if (!raw) return false
+  if (typeof raw === 'object') raw = raw.type || raw.license || ''
+  if (Array.isArray(raw)) return raw.some(isAllowedLicense)
+  const norm = String(raw).trim()
+  if (ALLOWED.has(norm)) return true
+  // Handle SPDX expressions like "(MIT OR Apache-2.0)"
+  const stripped = norm.replace(/^\(|\)$/g, '')
+  if (stripped.includes(' OR ')) {
+    return stripped.split(' OR ').some((p) => ALLOWED.has(p.trim()))
+  }
+  if (stripped.includes(' AND ')) {
+    return stripped.split(' AND ').every((p) => ALLOWED.has(p.trim()))
+  }
+  return false
+}
+
+function walkModules(dir, results = []) {
+  if (!fs.existsSync(dir)) return results
+  for (const name of fs.readdirSync(dir)) {
+    if (name === '.bin' || name === '.cache') continue
+    const full = path.join(dir, name)
+    let stat
+    try { stat = fs.statSync(full) } catch { continue }
+    if (!stat.isDirectory()) continue
+    if (name.startsWith('@')) {
+      // scoped: descend one level
+      walkModules(full, results)
+    } else {
+      const pkgPath = path.join(full, 'package.json')
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+          results.push({
+            name: pkg.name,
+            version: pkg.version,
+            license: pkg.license || pkg.licenses || null,
+            path: full,
+          })
+        } catch { /* skip malformed */ }
+      }
+      // Recurse into nested node_modules
+      const nested = path.join(full, 'node_modules')
+      if (fs.existsSync(nested)) walkModules(nested, results)
+    }
+  }
+  return results
+}
+
+const all = walkModules(MODULES)
+if (all.length === 0) {
+  console.log('No node_modules found. Run `npm install` first.')
+  process.exit(0)
+}
+
+const seen = new Set()
+const violations = []
+const unknown = []
+for (const m of all) {
+  const key = `${m.name}@${m.version}`
+  if (seen.has(key)) continue
+  seen.add(key)
+  if (!m.license) { unknown.push(m); continue }
+  if (!isAllowedLicense(m.license)) {
+    violations.push(m)
+  }
+}
+
+console.log(`Checked ${seen.size} unique packages.`)
+if (unknown.length > 0) {
+  console.log(`\n⚠️  ${unknown.length} packages have no license declared:`)
+  for (const m of unknown) console.log(`   ${m.name}@${m.version}`)
+}
+if (violations.length > 0) {
+  console.log(`\n❌ ${violations.length} packages with disallowed licenses:`)
+  for (const m of violations) {
+    const lic = typeof m.license === 'string' ? m.license : JSON.stringify(m.license)
+    console.log(`   ${m.name}@${m.version}  →  ${lic}`)
+  }
+  process.exit(1)
+}
+console.log('\n✅ All dependencies use permissive licenses.')

package/scripts/perf-test.js

@@ -0,0 +1,200 @@
+// Performance test for the linked-list grid + RR springs version.
+// Mirrors public/app.js step() exactly.
+
+const MAX_NODES = 300_000
+const SIZES = [1_000, 10_000, 30_000, 100_000, 300_000]
+const FRAMES = 30
+
+function makeSyntheticGraph(n) {
+  const nodes = []
+  const spread = Math.max(20, Math.sqrt(n) * 1.6)
+  for (let i = 0; i < n; i++) {
+    const r = 4 + Math.random() * spread
+    const theta = Math.random() * Math.PI * 2
+    nodes.push({
+      id: 'f' + i, idx: i,
+      p: { x: r * Math.cos(theta), y: (Math.random() - 0.5) * 8, z: r * Math.sin(theta) },
+      v: { x: 0, y: 0, z: 0 },
+      mass: 1 + Math.sqrt(Math.floor(Math.random() * 12)) * 1.6,
+    })
+  }
+  const edges = []
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < 3; j++) {
+      const t = Math.floor(Math.random() * n)
+      if (t !== i) edges.push({ s: nodes[i].id, t: nodes[t].id, k: 'import' })
+    }
+  }
+  return { nodes, edges }
+}
+
+const GRID_CELL = 11
+const GRID_INV = 1 / GRID_CELL
+const GRID_SIZE_BITS = 6
+const GRID_SIZE = 1 << GRID_SIZE_BITS
+const GRID_MASK = GRID_SIZE - 1
+const GRID_TOTAL = GRID_SIZE ** 3
+
+const cellHead = new Int32Array(GRID_TOTAL)
+const nextInCell = new Int32Array(MAX_NODES)
+
+function buildGrid(arr) {
+  cellHead.fill(-1)
+  const n = arr.length
+  for (let i = 0; i < n; i++) {
+    const p = arr[i].p
+    const cx = ((p.x * GRID_INV) | 0) & GRID_MASK
+    const cy = ((p.y * GRID_INV) | 0) & GRID_MASK
+    const cz = ((p.z * GRID_INV) | 0) & GRID_MASK
+    const cell = (cx << (GRID_SIZE_BITS * 2)) | (cy << GRID_SIZE_BITS) | cz
+    nextInCell[i] = cellHead[cell]
+    cellHead[cell] = i
+  }
+}
+
+let rrCursor = 0, springCursor = 0
+
+function step(arr, edges, nodeMap, alpha = 0.3, dt = 0.016) {
+  if (alpha === 0) return
+  const n = arr.length
+  const REPEL = 240, SPRING = 0.05, REST = 9
+  const CENTER = 0.0018, DISK = 0.012
+  const CUT2 = GRID_CELL * GRID_CELL * 2.25
+  const VEL_KEEP = 0.62
+
+  buildGrid(arr)
+
+  const RR_CHUNK = Math.min(n, Math.max(4000, Math.floor(120_000 / Math.max(1, Math.log2(n)))))
+  const PAIR_CAP_LOCAL = 32
+
+  for (let k = 0; k < RR_CHUNK; k++) {
+    const i = (rrCursor + k) % n
+    const ni = arr[i]
+    const aix = ni.p.x, aiy = ni.p.y, aiz = ni.p.z
+    const aim = ni.mass, invMi = 1 / aim
+    const cx = ((aix * GRID_INV) | 0) & GRID_MASK
+    const cy = ((aiy * GRID_INV) | 0) & GRID_MASK
+    const cz = ((aiz * GRID_INV) | 0) & GRID_MASK
+    let count = 0
+
+    for (let dx = -1; dx <= 1; dx++) {
+      const ncx = (cx + dx) & GRID_MASK
+      for (let dy = -1; dy <= 1; dy++) {
+        const ncy = (cy + dy) & GRID_MASK
+        for (let dz = -1; dz <= 1; dz++) {
+          const ncz = (cz + dz) & GRID_MASK
+          const cell = (ncx << (GRID_SIZE_BITS * 2)) | (ncy << GRID_SIZE_BITS) | ncz
+          let j = cellHead[cell]
+          while (j !== -1) {
+            if (j === i) { j = nextInCell[j]; continue }
+            const nj = arr[j]
+            const ex = aix - nj.p.x, ey = aiy - nj.p.y, ez = aiz - nj.p.z
+            const d2 = ex*ex + ey*ey + ez*ez
+            if (d2 > CUT2 || d2 < 0.0001) { j = nextInCell[j]; continue }
+            const safeD2 = d2 < 0.5 ? 0.5 : d2
+            const invD = 1 / Math.sqrt(d2)
+            const f = REPEL * aim * nj.mass / safeD2 * alpha * 0.5
+            const fx = ex * invD * f, fy = ey * invD * f, fz = ez * invD * f
+            ni.v.x += fx * invMi; ni.v.y += fy * invMi; ni.v.z += fz * invMi
+            const invMj = 1 / nj.mass
+            nj.v.x -= fx * invMj; nj.v.y -= fy * invMj; nj.v.z -= fz * invMj
+            if (++count > PAIR_CAP_LOCAL) { dx = 2; dy = 2; dz = 2; break }
+            j = nextInCell[j]
+          }
+        }
+      }
+    }
+  }
+  rrCursor = (rrCursor + RR_CHUNK) % n
+
+  const eLen = edges.length
+  if (eLen > 0) {
+    const SPRING_CHUNK = Math.min(eLen, Math.max(8000, Math.floor(200_000 / Math.max(1, Math.log2(eLen)))))
+    const springAlpha = alpha * Math.min(1, eLen / SPRING_CHUNK)
+    for (let k = 0; k < SPRING_CHUNK; k++) {
+      const idx = (springCursor + k) % eLen
+      const e = edges[idx]
+      const na = nodeMap.get(e.s), nb = nodeMap.get(e.t)
+      if (!na || !nb) continue
+      const ex = nb.p.x - na.p.x, ey = nb.p.y - na.p.y, ez = nb.p.z - na.p.z
+      const d2 = ex*ex + ey*ey + ez*ez
+      if (d2 < 1e-6) continue
+      const d = Math.sqrt(d2)
+      const f = SPRING * (d - REST) * springAlpha / d
+      const fx = ex * f, fy = ey * f, fz = ez * f
+      const inv1 = 1 / na.mass, inv2 = 1 / nb.mass
+      na.v.x += fx * inv1; na.v.y += fy * inv1; na.v.z += fz * inv1
+      nb.v.x -= fx * inv2; nb.v.y -= fy * inv2; nb.v.z -= fz * inv2
+    }
+    springCursor = (springCursor + SPRING_CHUNK) % eLen
+  }
+
+  const CA = CENTER * alpha, DA = DISK * alpha, DT6 = dt * 6
+  for (let i = 0; i < n; i++) {
+    const node = arr[i]
+    const p = node.p, v = node.v
+    v.x += -p.x * CA
+    v.y += -p.y * CA - p.y * DA
+    v.z += -p.z * CA
+    v.x *= VEL_KEEP; v.y *= VEL_KEEP; v.z *= VEL_KEEP
+    p.x += v.x * DT6; p.y += v.y * DT6; p.z += v.z * DT6
+  }
+}
+
+function writeBuffers(arr) {
+  const n = arr.length
+  const positions = new Float32Array(n * 3)
+  for (let i = 0; i < n; i++) {
+    positions[i*3]   = arr[i].p.x
+    positions[i*3+1] = arr[i].p.y
+    positions[i*3+2] = arr[i].p.z
+  }
+}
+
+console.log('Performance test — flat grid + RR repulsion + RR springs + inlined math')
+console.log('Targets: <16ms=60fps, <33ms=30fps, <100ms=10fps\n')
+console.log('              SIMULATING (during first ~5s of layout)   SETTLED (steady state)')
+console.log('              ─────────────────────────────────────     ─────────────────────')
+
+function stepSettled(arr, dt = 0.016) {
+  // Mirror app.js settled-state fast path (alpha == 0)
+  const n = arr.length
+  for (let i = 0; i < n; i++) {
+    const v = arr[i].v
+    if (v.x * v.x + v.y * v.y + v.z * v.z < 0.0002) { v.x = 0; v.y = 0; v.z = 0; continue }
+    v.x *= 0.62; v.y *= 0.62; v.z *= 0.62
+    const p = arr[i].p
+    p.x += v.x * dt * 6; p.y += v.y * dt * 6; p.z += v.z * dt * 6
+  }
+}
+
+for (const N of SIZES) {
+  const { nodes, edges } = makeSyntheticGraph(N)
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]))
+  rrCursor = 0; springCursor = 0
+
+  // Warm-up
+  step(nodes, edges, nodeMap, 0.3)
+  step(nodes, edges, nodeMap, 0.3)
+
+  // Active simulation
+  const t0 = performance.now()
+  for (let f = 0; f < FRAMES; f++) {
+    step(nodes, edges, nodeMap, 0.3)
+    writeBuffers(nodes)
+  }
+  const msSim = (performance.now() - t0) / FRAMES
+
+  // Settled — zero velocity, just buffer write
+  for (const node of nodes) { node.v.x = 0; node.v.y = 0; node.v.z = 0 }
+  const t1 = performance.now()
+  for (let f = 0; f < FRAMES; f++) {
+    stepSettled(nodes)
+    writeBuffers(nodes)
+  }
+  const msSettled = (performance.now() - t1) / FRAMES
+
+  const v1 = msSim < 18 ? '🟢' : msSim < 34 ? '🟡' : msSim < 105 ? '🟠' : '🔴'
+  const v2 = msSettled < 18 ? '🟢' : msSettled < 34 ? '🟡' : msSettled < 105 ? '🟠' : '🔴'
+  console.log(`${N.toString().padStart(7)} nodes  ${msSim.toFixed(1).padStart(6)} ms (${(1000/msSim).toFixed(0).padStart(3)} fps) ${v1}    ${msSettled.toFixed(1).padStart(6)} ms (${(1000/msSettled).toFixed(0).padStart(3)} fps) ${v2}`)
+}