visualproof 0.0.0-stage → 0.1.0

package/dist/web/bundle/edges.js

@@ -0,0 +1,409 @@
+// src/shared/graph.ts
+var SITE_STMT = 1;
+var SITE_BODY = 2;
+var SITE_PROOF = 4;
+var SITE_GRAMMAR = 8;
+var SITE_TCB = SITE_STMT | SITE_BODY;
+
+// src/web/src/bundles.ts
+var MAX_POINTS = 8;
+function units(S, k, minPx) {
+  const cu = new Int32Array(S.nc).fill(-1);
+  for (let c = 0; c < S.nc; c++) {
+    const p = S.parent[c];
+    if (p >= 0 && cu[p] >= 0) cu[c] = cu[p];
+    else if (S.rep[c] === c || S.curR[c] * k < minPx) cu[c] = c;
+  }
+  const out = new Int32Array(S.n);
+  for (let i = 0; i < S.n; i++) {
+    const c = S.nodeCluster[i];
+    out[i] = c >= 0 && cu[c] >= 0 ? cu[c] : S.nc + i;
+  }
+  return out;
+}
+function aggregate(g, unit, sites, keep) {
+  const counts = /* @__PURE__ */ new Map();
+  const W = 1 << 22;
+  for (let u = 0; u < g.n; u++) {
+    if (!keep(u)) continue;
+    const a = unit[u];
+    for (let e = g.outStart[u]; e < g.outStart[u + 1]; e++) {
+      if (!(g.outSite[e] & sites)) continue;
+      const v = g.outDst[e];
+      if (!keep(v)) continue;
+      const b = unit[v];
+      if (a === b) continue;
+      const key = a * W + b;
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+  }
+  const n = counts.size;
+  const out = { n, a: new Int32Array(n), b: new Int32Array(n), w: new Int32Array(n) };
+  let k = 0;
+  for (const [key, w] of counts) {
+    const a = Math.floor(key / W);
+    out.a[k] = a;
+    out.b[k] = key - a * W;
+    out.w[k] = w;
+    k++;
+  }
+  return out;
+}
+function topK(idx, score, cap) {
+  const n = idx.length;
+  if (n <= cap) return idx;
+  const s = new Float64Array(n);
+  for (let k = 0; k < n; k++) s[k] = score[idx[k]];
+  const want = n - cap;
+  let lo = 0, hi = n - 1;
+  while (lo < hi) {
+    const pivot = s[lo + hi >> 1];
+    let i = lo, j = hi;
+    while (i <= j) {
+      while (s[i] < pivot) i++;
+      while (s[j] > pivot) j--;
+      if (i <= j) {
+        const t = s[i];
+        s[i] = s[j];
+        s[j] = t;
+        i++;
+        j--;
+      }
+    }
+    if (want <= j) hi = j;
+    else if (want >= i) lo = i;
+    else break;
+  }
+  const threshold = s[want];
+  const out = new Int32Array(cap);
+  let m = 0;
+  for (let k = 0; k < n && m < cap; k++) if (score[idx[k]] > threshold) out[m++] = idx[k];
+  for (let k = 0; k < n && m < cap; k++) if (score[idx[k]] === threshold) out[m++] = idx[k];
+  return out;
+}
+function pathOf(S, a, b) {
+  const chain = (id) => {
+    const out = [id];
+    let c = id < S.nc ? S.parent[id] : S.nodeCluster[id - S.nc];
+    while (c >= 0) {
+      out.push(c);
+      c = S.parent[c];
+    }
+    return out;
+  };
+  return joinChains(chain(a), chain(b));
+}
+function joinChains(ca, cb) {
+  const inB = /* @__PURE__ */ new Map();
+  cb.forEach((x, k) => inB.set(x, k));
+  let path;
+  const ka = ca.findIndex((x) => inB.has(x));
+  if (ka >= 0) {
+    const kb = inB.get(ca[ka]);
+    path = [...ca.slice(0, ka + 1), ...cb.slice(0, kb).reverse()];
+    if (path.length < 2) path = [ca[0], cb[0]];
+  } else {
+    path = [...ca, ...[...cb].reverse()];
+  }
+  if (path.length > MAX_POINTS) {
+    const keep = [path[0]];
+    for (let k = 1; k < MAX_POINTS - 1; k++) keep.push(path[Math.round(k * (path.length - 1) / (MAX_POINTS - 1))]);
+    keep.push(path[path.length - 1]);
+    path = keep;
+  }
+  return path;
+}
+
+// src/web/src/overview.ts
+var ZOOM_POINT = 0.25;
+function blendLooks(a, b, t, put) {
+  const A = t >= 1 ? null : a;
+  const B = t <= 0 ? null : b;
+  const give = (e, beta, width, alpha, key) => {
+    if (alpha > 2e-3) put(e, beta, width, alpha, key);
+  };
+  if (A)
+    for (const [key, x] of A) {
+      const y = B?.get(key);
+      if (y) give(y, x.beta + (y.beta - x.beta) * t, x.width + (y.width - x.width) * t, x.alpha + (y.alpha - x.alpha) * t, key);
+      else give(x, x.beta, x.width, x.alpha * (1 - t), key);
+    }
+  if (B) {
+    for (const [key, y] of B) if (!A?.has(key)) give(y, y.beta, y.width, y.alpha * t, key);
+  }
+}
+function smoothstep(a, b, x) {
+  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+  return t * t * (3 - 2 * t);
+}
+var looksBuffers = (L) => [L.a, L.b, L.path, L.len, L.beta, L.width, L.alpha].map((x) => x.buffer);
+function pack(looks) {
+  const n = looks.size;
+  const L = {
+    n,
+    a: new Int32Array(n),
+    b: new Int32Array(n),
+    path: new Int32Array(8 * n),
+    len: new Uint8Array(n),
+    beta: new Float64Array(n),
+    width: new Float64Array(n),
+    alpha: new Float64Array(n)
+  };
+  let j = 0;
+  for (const e of looks.values()) {
+    L.a[j] = e.path[0];
+    L.b[j] = e.path[e.path.length - 1];
+    L.path.set(e.path, 8 * j);
+    L.len[j] = e.path.length;
+    L.beta[j] = e.beta;
+    L.width[j] = e.width;
+    L.alpha[j] = e.alpha;
+    j++;
+  }
+  return L;
+}
+var LEVELS_KEPT = 6;
+var OverviewModel = class {
+  g = null;
+  tree = null;
+  toggles = { externals: true, proofs: false };
+  levels = /* @__PURE__ */ new Map();
+  setGraph(g) {
+    this.g = g;
+    this.levels.clear();
+  }
+  setTree(tree, toggles) {
+    this.tree = tree;
+    this.toggles = { ...toggles };
+    this.levels.clear();
+  }
+  /** How many zoom steps' aggregations are held (for the tests). */
+  get levelCount() {
+    return this.levels.size;
+  }
+  /** What the overview draws at zoom point `ask.point` (zoom 2^(point · ZOOM_POINT / 2)), for the
+   *  camera centred at (x, y), with everything where `places` has it: chosen from the aggregations of
+   *  the two steps the point lies between, blended as it lies between them — none of the finer over
+   *  the first fifth of the way, all of it over the last fifth, smoothly between. */
+  choose(ask, places) {
+    if (!this.g || !this.tree) throw new Error("the overview has no graph or no tree yet");
+    const zs = ask.point * ZOOM_POINT;
+    const cam = { x: ask.x, y: ask.y, k: Math.pow(2, zs / 2) };
+    const lo = Math.floor(zs);
+    const up = smoothstep(0.2, 0.8, zs - lo);
+    const at = (level) => {
+      let v = this.levels.get(level);
+      if (v) this.levels.delete(level);
+      else v = this.aggregateLevel(level, places);
+      this.levels.set(level, v);
+      while (this.levels.size > LEVELS_KEPT) this.levels.delete(this.levels.keys().next().value);
+      return this.looksOf(v, this.chooseLevel(v, cam, ask, places), ask, places);
+    };
+    const coarse = up < 1 ? at(lo) : null;
+    const fine = up > 0 ? at(lo + 1) : null;
+    const looks = /* @__PURE__ */ new Map();
+    blendLooks(coarse, fine, up, (e, beta, width, alpha, key) => looks.set(key, { path: e.path, beta, width, alpha }));
+    return pack(looks);
+  }
+  /** The aggregation of zoom step `level`: each node's unit as the camera at 2^(level/2) sees it,
+   *  and the edges between units, counted. */
+  aggregateLevel(level, places) {
+    const g = this.g;
+    const unit = units({ ...this.tree, curR: places.curR }, Math.pow(2, level / 2), 45);
+    const sites = SITE_STMT | SITE_BODY | (this.toggles.proofs ? SITE_PROOF | SITE_GRAMMAR : 0);
+    const ext = this.toggles.externals;
+    const pairs = aggregate(g, unit, sites, (i) => i < g.projectCount || ext);
+    return { pairs, units: Int32Array.from(new Set(unit)) };
+  }
+  /** Choose what step `v` draws for a camera `cam`. About 0.6 per unit on screen (between 250 and
+   *  1,500), so that zoomed in each stays an edge one can follow: those with both ends in view
+   *  first (heaviest first; among equals the short ones, then those nearest the middle of the
+   *  screen), then, in up to a fifth of the budget, those leaving the view (heaviest first): what
+   *  the part in view uses, or is used by, elsewhere. The limit is soft: the next fifth past it is
+   *  drawn fainter the further past it. */
+  chooseLevel(v, cam, ask, S) {
+    const P = v.pairs;
+    const hw = ask.w / 2 / cam.k, hh = ask.h / 2 / cam.k;
+    const x0 = cam.x - hw * 1.25, x1 = cam.x + hw * 1.25, y0 = cam.y - hh * 1.25, y1 = cam.y + hh * 1.25;
+    const diag = Math.hypot(hw, hh);
+    const nc = this.tree.nc;
+    const X = (id) => id < nc ? S.cwx[id] : S.nwx[id - nc];
+    const Y = (id) => id < nc ? S.cwy[id] : S.nwy[id - nc];
+    const U = v.units;
+    let onScreen = 0;
+    for (let k = 0; k < U.length; k++) {
+      const x = X(U[k]), y = Y(U[k]);
+      if (Math.abs(x - cam.x) <= hw && Math.abs(y - cam.y) <= hh) onScreen++;
+    }
+    const budget = Math.max(250, Math.min(1500, Math.round(0.6 * onScreen)));
+    const score = new Float64Array(P.n);
+    const both = [];
+    const one = [];
+    for (let k = 0; k < P.n; k++) {
+      const ax = X(P.a[k]), ay = Y(P.a[k]), bx = X(P.b[k]), by = Y(P.b[k]);
+      const ia = ax >= x0 && ax <= x1 && ay >= y0 && ay <= y1;
+      const ib = bx >= x0 && bx <= x1 && by >= y0 && by <= y1;
+      if (!ia && !ib) continue;
+      if (ia && ib) {
+        const len = Math.hypot(bx - ax, by - ay) / diag;
+        const d = Math.hypot((ax + bx) / 2 - cam.x, (ay + by) / 2 - cam.y) / diag;
+        score[k] = P.w[k] + 0.55 * (1 - Math.min(1, len)) + 0.4 * (1 - Math.min(1, d));
+        both.push(k);
+      } else {
+        score[k] = P.w[k];
+        one.push(k);
+      }
+    }
+    const soft = (n2) => Math.ceil(n2 * 1.2);
+    const ranked = (idx, cap) => {
+      const top = Array.from(topK(Int32Array.from(idx), score, soft(cap))).sort((a, b) => score[b] - score[a]);
+      const strength2 = new Float32Array(top.length);
+      const span = Math.max(1, soft(cap) - cap);
+      for (let r = 0; r < top.length; r++) strength2[r] = r < cap ? 1 : Math.max(0, 1 - (r - cap + 1) / (span + 1));
+      return { idx: Int32Array.from(top), strength: strength2 };
+    };
+    const innerCap = budget - Math.min(Math.round(budget / 5), one.length);
+    const inner = ranked(both, innerCap);
+    const outer = ranked(one, budget - Math.min(inner.idx.length, innerCap));
+    const n = inner.idx.length + outer.idx.length;
+    const sel = new Int32Array(n), inside = new Uint8Array(n), strength = new Float32Array(n);
+    sel.set(inner.idx);
+    sel.set(outer.idx, inner.idx.length);
+    inside.fill(1, 0, inner.idx.length);
+    strength.set(inner.strength);
+    strength.set(outer.strength, inner.idx.length);
+    return { sel, inside, strength };
+  }
+  /** How step `v` draws what was chosen of it, each edge by its units' ids (`a:b`): width and alpha
+   *  grow with the weight relative to the heaviest chosen of their kind (in view, or leaving it), so
+   *  zoomed in a single dependency between two declarations reads as clearly as a heavy bundle does
+   *  zoomed out; an edge past the soft limit fainter by its rank. */
+  looksOf(v, chosen, ask, S) {
+    const P = v.pairs;
+    const T = this.tree;
+    const { sel, inside, strength } = chosen;
+    let maxIn = 1, maxOut = 1, nIn = 0, n = 0;
+    for (let j = 0; j < sel.length; j++) {
+      const w = P.w[sel[j]];
+      n += strength[j];
+      if (inside[j]) {
+        maxIn = Math.max(maxIn, w);
+        nIn += strength[j];
+      } else maxOut = Math.max(maxOut, w);
+    }
+    const nc = T.nc;
+    const X = (id) => id < nc ? S.cwx[id] : S.nwx[id - nc];
+    const Y = (id) => id < nc ? S.cwy[id] : S.nwy[id - nc];
+    const crowd = Math.min(1, Math.sqrt(400 / Math.max(1, n)));
+    const fade = (ask.dim ? DIM : 1) * crowd;
+    const floor = 0.05 + 0.3 * Math.min(1, Math.max(0, (1200 - nIn) / 900));
+    const looks = /* @__PURE__ */ new Map();
+    for (let j = 0; j < sel.length; j++) {
+      const k = sel[j];
+      const a = P.a[k], b = P.b[k], w = P.w[k];
+      const max = inside[j] ? maxIn : maxOut;
+      const t = Math.log1p(w) / Math.log1p(max);
+      const width = 0.7 + 2 * t * Math.min(1, Math.log1p(max) / Math.log1p(50));
+      const alpha = (floor + (0.45 - floor) * t * t) * fade * strength[j];
+      const path = pathOf(T, a, b);
+      let R = 0;
+      for (let q = 1; q < path.length - 1; q++) if (path[q] < nc) R = Math.max(R, S.drawnR[path[q]]);
+      const d = Math.hypot(X(b) - X(a), Y(b) - Y(a));
+      const beta = R > 0 ? 0.85 * Math.min(1, 2 * d / R) : 0.85;
+      looks.set(`${a}:${b}`, { path, beta, width, alpha });
+    }
+    return looks;
+  }
+};
+var DIM = 0.12;
+
+// src/web/src/edgeworker.ts
+var EdgeWorkerCore = class {
+  model = new OverviewModel();
+  base = -1;
+  lo = -Infinity;
+  hi = Infinity;
+  queue = [];
+  /** Take one message in; `choose` waits in the queue for `next`. */
+  receive(m, post) {
+    switch (m.type) {
+      case "graph":
+        this.model.setGraph({ n: m.n, projectCount: m.projectCount, outStart: m.outStart, outDst: m.outDst, outSite: m.outSite });
+        break;
+      case "tree":
+        this.base = m.base;
+        this.model.setTree(
+          { nc: m.nc, n: m.n, parent: m.parent, nodeCluster: m.nodeCluster, rep: m.rep },
+          { externals: m.externals, proofs: m.proofs }
+        );
+        this.prune(post);
+        break;
+      case "near":
+        if (m.base === this.base) {
+          this.lo = m.lo;
+          this.hi = m.hi;
+        }
+        this.prune(post);
+        break;
+      case "choose":
+        this.queue.push(m);
+        break;
+    }
+  }
+  /** Whether a question waits. */
+  get waiting() {
+    return this.queue.length;
+  }
+  /** Drop what is no longer wanted: another tree's questions, points outside the window, and a point
+   *  asked again since (the later question wins). */
+  prune(post) {
+    const keep = [];
+    for (let k = 0; k < this.queue.length; k++) {
+      const q = this.queue[k];
+      const later = this.queue.some((r, j) => j > k && r.point === q.point && r.base === q.base);
+      if (q.base !== this.base || q.point < this.lo || q.point > this.hi || later) post({ type: "dropped", id: q.id });
+      else keep.push(q);
+    }
+    this.queue = keep;
+  }
+  /** Answer the next question: what the camera needs before what is asked ahead, the first asked
+   *  among equals. */
+  next(post) {
+    this.prune(post);
+    if (!this.queue.length) return;
+    let k = 0;
+    for (let j = 1; j < this.queue.length; j++) if (this.queue[j].pri < this.queue[k].pri) k = j;
+    const [q] = this.queue.splice(k, 1);
+    const t0 = performance.now();
+    try {
+      const looks = this.model.choose(q, q.places);
+      post({ type: "looks", id: q.id, point: q.point, looks, ms: performance.now() - t0 }, looksBuffers(looks));
+    } catch (err) {
+      post({ type: "error", id: q.id, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+};
+var scope = globalThis;
+if (typeof scope.document === "undefined" && typeof globalThis.WorkerGlobalScope !== "undefined") {
+  const core = new EdgeWorkerCore();
+  const post = (a, transfer) => scope.postMessage(a, transfer ?? []);
+  const turn = new MessageChannel();
+  let scheduled = false;
+  turn.port1.onmessage = () => {
+    scheduled = false;
+    core.next(post);
+    if (core.waiting) schedule();
+  };
+  const schedule = () => {
+    if (scheduled) return;
+    scheduled = true;
+    turn.port2.postMessage(0);
+  };
+  scope.onmessage = (e) => {
+    core.receive(e.data, post);
+    if (core.waiting) schedule();
+  };
+}
+export {
+  EdgeWorkerCore
+};