@kanzo-tech/graph 0.2.0 → 0.3.0

package/dist/duck-source.js

@@ -1,15 +1,17 @@
 "use client";
-import { numbers as k, clausePoints as $t, fillColumn as M, column as pt } from "@kanzo-tech/mosaic";
-import { SliceRead as W } from "./slice-client.js";
-import { typeOf as xt, denseOf as tt, vertexId as At } from "./resident.js";
-function et(t, e) {
+import { open as at, PAYLOAD_COORDINATES as k, PAYLOAD_IDENTITY as it, PAYLOAD_ADDRESS as ot } from "@fossil-lang/corpus";
+import { numbers as C, clausePoints as rt, fillColumn as _, column as ct } from "@kanzo-tech/mosaic";
+import { SliceRead as v } from "./slice-client.js";
+import { typeOf as lt, denseOf as J, vertexId as ut } from "./resident.js";
+const X = 0;
+function Et(t, e) {
   return {
-    points: new W(t, e),
-    links: new W(t, e),
-    meta: new W(t)
+    points: new v(t, e),
+    links: new v(t, e),
+    meta: new v(t)
   };
 }
-function nt(t) {
+function dt(t) {
   let e = Promise.resolve();
   return (n) => {
     const s = e.then(() => t.ask(() => n));
@@ -17,97 +19,49 @@ function nt(t) {
     }), s;
   };
 }
-function Q(t) {
+function Y(t) {
   if (t == null) return "";
   const n = (Array.isArray(t) ? t : [t]).filter((s) => s != null).map((s) => String(s));
   return n.length > 0 ? n.map((s) => `(${s})`).join(" AND ") : "";
 }
-function st(t, e) {
+function Z(t, e) {
   return t ? e ? `(${t}) AND (${e})` : t : e || "TRUE";
 }
-function wt(t) {
-  const { coordinator: e, edges: n, filterBy: s, nodes: r, typeIndex: i } = t, c = {
-    id: t.idField ?? "id",
-    subject: t.subjectField,
-    x: t.xField ?? "x",
-    y: t.yField ?? "y",
-    source: t.sourceField ?? "source",
-    target: t.targetField ?? "target"
-  }, l = et(e, s), E = nt(l.meta), y = it(l);
-  return {
-    ...y.api,
-    publish(p) {
-      ot(l, s, c.id, p);
-    },
-    async total() {
-      const p = await E(`SELECT count(*) AS n FROM ${r}`);
-      return Number(k(p, "n")[0] ?? 0);
-    },
-    /**
-     * Four aggregates, so the canvas can frame what is actually there.
-     *
-     * One scan of two columns, once — against a first paint that otherwise opens on the renderer's
-     * default box and finds the corpus occupying a corner of it.
-     */
-    async extent() {
-      const p = await E(
-        `SELECT min(${c.x}) AS x0, max(${c.x}) AS x1,
-                min(${c.y}) AS y0, max(${c.y}) AS y1
-         FROM ${r}`
-      ), x = (f) => Number(k(p, f)[0] ?? 0);
-      return { xMin: x("x0"), yMin: x("y0"), xMax: x("x1"), yMax: x("y1") };
-    },
-    /**
-     * Regions only, and it says so by **not having** `explore`.
-     *
-     * This source is two relations and a spatial predicate — it has no adjacency index, so a
-     * neighbourhood query would mean recursive joins over the whole edge table, which is the
-     * unbounded pattern wearing a bounded interface. It used to say that with a predicate and a
-     * throw; now the absence is the statement, and asking is a compile error.
-     */
-    async slice(p) {
-      const { fill: x, limit: f, minLinkPixels: N, perPixel: $, pinned: O, r: g, view: F } = p, A = { ...c, category: x, size: g };
-      return y.run(
-        rt(r, n, A, F, f, i, O, $, N, void 0)
-      );
-    }
-  };
-}
-function St(t, e) {
+function mt(t, e) {
   const s = [
     [t.x, e.xMin, ">="],
     [t.x, e.xMax, "<="],
     [t.y, e.yMin, ">="],
     [t.y, e.yMax, "<="]
-  ].filter(([, r]) => Number.isFinite(r)).map(([r, i, c]) => `${r} ${c} ${i}`);
+  ].filter(([, o]) => Number.isFinite(o)).map(([o, r, l]) => `${o} ${l} ${r}`);
   return s.length > 0 ? s.join(" AND ") : "TRUE";
 }
-const ht = (t) => `greatest(1, CAST(ceil(matched / ${t}.0) AS BIGINT))`;
-function q(t, e, n, s, r = !0) {
-  const i = e.size ? `, ${e.size} AS size` : "", c = e.subject ? `, ${e.subject} AS subject` : "", l = e.category ? "(dense_rank() OVER (ORDER BY cat) - 1)::INTEGER AS category" : "0::INTEGER AS category";
+const At = (t) => `greatest(1, CAST(ceil(matched / ${t}.0) AS BIGINT))`;
+function q(t, e, n, s, o = !0) {
+  const r = e.size ? `, ${e.size} AS size` : "", l = e.subject ? `, ${e.subject} AS subject` : "", m = e.category ? "(dense_rank() OVER (ORDER BY cat) - 1)::INTEGER AS category" : "0::INTEGER AS category";
   return `WITH pool AS (
-    SELECT ${e.id} AS id, ${e.x} AS x, ${e.y} AS y${i}${c}${e.category ? `, ${e.category} AS cat` : ""},
+    SELECT ${e.id} AS id, ${e.x} AS x, ${e.y} AS y${r}${l}${e.category ? `, ${e.category} AS cat` : ""},
            count(*) OVER () AS matched
     FROM ${t}
     WHERE ${n}
   ), vis AS (
-    SELECT id, x, y${e.size ? ", size" : ""}${e.subject ? ", subject" : ""}${r ? ", matched" : ""},
-           ${l},
+    SELECT id, x, y${e.size ? ", size" : ""}${e.subject ? ", subject" : ""}${o ? ", matched" : ""},
+           ${m},
            (row_number() OVER (ORDER BY id) - 1)::INTEGER AS local
     FROM pool
-    WHERE id % ${ht(s)} = 0
+    WHERE id % ${At(s)} = 0
     LIMIT ${s}
   )`;
 }
-function at(t, e, n, s) {
+function yt(t, e, n, s) {
   if (n === void 0 || !Number.isFinite(n) || n <= 0) return "";
-  const r = s * n;
-  return `(${t}.x - ${e}.x) * (${t}.x - ${e}.x) + (${t}.y - ${e}.y) * (${t}.y - ${e}.y) >= ${r * r}`;
+  const o = s * n;
+  return `(${t}.x - ${e}.x) * (${t}.x - ${e}.x) + (${t}.y - ${e}.y) * (${t}.y - ${e}.y) >= ${o * o}`;
 }
-function ft(t, e, n, s, r, i, c) {
-  const l = st(`NOT (${s})`, r), E = at("a", "b", i, c);
+function pt(t, e, n, s, o, r, l) {
+  const m = Z(`NOT (${s})`, o), E = yt("a", "b", r, l);
   return `, out AS (
-    SELECT ${n.id} AS id, ${n.x} AS x, ${n.y} AS y FROM ${t} WHERE ${l}
+    SELECT ${n.id} AS id, ${n.x} AS x, ${n.y} AS y FROM ${t} WHERE ${m}
   ), reach AS (
     SELECT id, x, y FROM vis UNION ALL SELECT id, x, y FROM out
   ), span AS (
@@ -126,8 +80,8 @@ function ft(t, e, n, s, r, i, c) {
                    UNION SELECT dst_id FROM span WHERE dst IS NULL)
   )`;
 }
-function rt(t, e, n, s, r, i, c, l, E, y) {
-  const p = St(n, s), x = (c ?? []).filter((u) => xt(u) === i).map(tt), f = x.length > 0 ? ` OR ${n.id} IN (${x.join(",")})` : "", N = `(${p})${f}`, $ = (u) => st(N, Q(u)), O = n.size ? ", size" : "", g = n.subject ? ", subject" : "", F = at("s", "t", l, E), A = (u) => y ? ft(y, e, n, N, Q(u), l, E) : "";
+function $t(t, e, n, s, o, r, l, m) {
+  const E = mt(n, s), h = (r ?? []).filter((u) => lt(u) === X).map(J), b = h.length > 0 ? ` OR ${n.id} IN (${h.join(",")})` : "", R = `(${E})${b}`, y = (u) => Z(R, Y(u)), A = n.size ? ", size" : "", x = n.subject ? ", subject" : "", f = (u) => pt(t, e, n, R, Y(u), l, m);
   return {
     /**
      * The marks, then the anchors, in one answer — because they are one buffer.
@@ -136,30 +90,26 @@ function rt(t, e, n, s, r, i, c, l, E, y) {
      * and continues past it over the anchors, so ordering by it puts every mark before every anchor
      * and makes `marks` a prefix length. `matched` is then still read off row zero.
      */
-    points: (u) => `${q(t, n, $(u), r)}${A(u)}
-       SELECT local, id, x, y, category, matched, TRUE AS mark${O}${g} FROM vis${y ? `
+    points: (u) => `${q(t, n, y(u), o)}${f(u)}
+       SELECT local, id, x, y, category, matched, TRUE AS mark${A}${x} FROM vis
        UNION ALL
-       SELECT local, id, x, y, 0::INTEGER, NULL::BIGINT, FALSE AS mark${n.size ? ", CAST(NULL AS DOUBLE)" : ""}${n.subject ? ", CAST(NULL AS VARCHAR)" : ""} FROM anchor` : ""}
+       SELECT local, id, x, y, 0::INTEGER, NULL::BIGINT, FALSE AS mark${n.size ? ", CAST(NULL AS DOUBLE)" : ""}${n.subject ? ", CAST(NULL AS VARCHAR)" : ""} FROM anchor
        ORDER BY local`,
     /**
-     * One end drawn and both ends positioned — or, where nothing is held, both ends drawn.
+     * One end drawn and both ends positioned.
      *
-     * The second form is what a source over an ordinary relation gets, and it is the old query plus
-     * the length predicate. It still drops an edge that leaves the window, and the reason is now
-     * exact rather than a limitation of the reader: no bytes beyond the rectangle were fetched, so
-     * there is no position to draw the far end at. A corpus fetches tiles and therefore has some.
+     * There was a second form here — both ends drawn, edges leaving the window dropped — for a source
+     * that fetched no bytes beyond the rectangle and therefore had no position to put a far end at.
+     * It went with that source, and `longEnough` with it — the length predicate lives in `anchorCte`
+     * now, on the same span, which is where it has to sit once the join runs over the held rows
+     * rather than over the visible ones.
      */
-    links: (u) => y ? `${q(t, n, $(u), r, !1)}${A(u)}
+    links: (u) => `${q(t, n, y(u), o, !1)}${f(u)}
         SELECT coalesce(sp.src, sa.local) AS src, coalesce(sp.dst, da.local) AS dst
         FROM span sp
         LEFT JOIN anchor sa ON sa.id = sp.src_id
-        LEFT JOIN anchor da ON da.id = sp.dst_id` : `${q(t, n, $(u), r, !1)}
-        SELECT s.local AS src, t.local AS dst
-        FROM ${e} e
-        JOIN vis s ON e.${n.source} = s.id
-        JOIN vis t ON e.${n.target} = t.id${F ? `
-        WHERE ${F}` : ""}`,
-    assemble: (u, D) => ({
+        LEFT JOIN anchor da ON da.id = sp.dst_id`,
+    assemble: (u, p) => ({
       /**
        * How many matched, separately from how many came back.
        *
@@ -168,17 +118,17 @@ function rt(t, e, n, s, r, i, c, l, E, y) {
        * has been about. Read off the first row rather than asked for: `matched` is constant down the
        * column, and an empty answer has no row and no matches, which agree.
        */
-      n: Number(k(u, "matched")[0] ?? 0),
-      ...Nt(u, D, i, n.size ? "size" : void 0, n.subject !== void 0)
+      n: Number(C(u, "matched")[0] ?? 0),
+      ...Rt(u, p, n.size ? "size" : void 0, n.subject !== void 0)
     })
   };
 }
-function it(t) {
+function St(t) {
   let e = null, n = null;
-  const s = /* @__PURE__ */ new Map(), r = (i) => (c) => {
-    if (!e || !n || (s.set(i, c), s.size < 2)) return;
-    const l = s.get("points"), E = s.get("links");
-    s.clear(), n(e.assemble(l, E));
+  const s = /* @__PURE__ */ new Map(), o = (r) => (l) => {
+    if (!e || !n || (s.set(r, l), s.size < 2)) return;
+    const m = s.get("points"), E = s.get("links");
+    s.clear(), n(e.assemble(m, E));
   };
   return {
     api: {
@@ -189,202 +139,182 @@ function it(t) {
        * has *already* re-run both reads with the new predicate by the time we hear about it. Asking
        * again would run the same two queries a second time to learn what is in hand.
        */
-      watch(i) {
-        return n = i, t.points.onAnswer = r("points"), t.links.onAnswer = r("links"), () => {
+      watch(r) {
+        return n = r, t.points.onAnswer = o("points"), t.links.onAnswer = o("links"), () => {
           n = null, s.clear(), e = null, t.points.release(), t.links.release(), t.meta.release();
         };
       }
     },
-    async run(i) {
-      e = i, s.clear();
-      const [c, l] = await Promise.all([
-        t.points.ask(i.points),
-        t.links.ask(i.links)
+    async run(r) {
+      e = r, s.clear();
+      const [l, m] = await Promise.all([
+        t.points.ask(r.points),
+        t.links.ask(r.links)
       ]);
-      return i.assemble(c, l);
+      return r.assemble(l, m);
     }
   };
 }
-function ot(t, e, n, s) {
+function Nt(t, e, n, s) {
   e && e.update(
-    $t([n], s == null ? void 0 : s.map((r) => [tt(r)]), {
+    rt([n], s == null ? void 0 : s.map((o) => [J(o)]), {
       source: t.points,
       clients: /* @__PURE__ */ new Set([t.points, t.links])
     })
   );
 }
-function Nt(t, e, n, s, r = !1) {
-  const i = X(t, "x"), c = new Float32Array(i * 2), l = M(t, "x", c, 0, 2);
-  M(t, "y", c, 1, 2);
-  const E = new Int32Array(i);
-  M(t, "mark", E);
-  let y = 0;
-  for (; y < l && E[y] !== 0; ) y++;
-  const p = new Float64Array(l);
-  M(t, "id", p);
-  const x = new BigUint64Array(l);
-  for (let A = 0; A < l; A++) x[A] = At(n, p[A]);
-  const f = new Uint16Array(l);
-  M(t, "category", f);
-  const N = r ? pt(t, "subject") : void 0;
-  let $;
-  s && ($ = new Float32Array(l), M(t, s, $));
-  const O = X(e, "src"), g = new Float32Array(O * 2), F = M(e, "src", g, 0, 2);
-  return M(e, "dst", g, 1, 2), {
-    marks: y,
-    vertices: x,
-    subjects: N,
-    positions: c.subarray(0, l * 2),
-    links: g.subarray(0, F * 2),
-    categories: f,
-    sizes: $
+function Rt(t, e, n, s = !1) {
+  const o = V(t, "x"), r = new Float32Array(o * 2), l = _(t, "x", r, 0, 2);
+  _(t, "y", r, 1, 2);
+  const m = new Int32Array(o);
+  _(t, "mark", m);
+  let E = 0;
+  for (; E < l && m[E] !== 0; ) E++;
+  const h = new Float64Array(l);
+  _(t, "id", h);
+  const b = new BigUint64Array(l);
+  for (let p = 0; p < l; p++) b[p] = ut(X, h[p]);
+  const R = new Uint16Array(l);
+  _(t, "category", R);
+  const y = s ? ct(t, "subject") : void 0;
+  let A;
+  n && (A = new Float32Array(l), _(t, n, A));
+  const x = V(e, "src"), f = new Float32Array(x * 2), u = _(e, "src", f, 0, 2);
+  return _(e, "dst", f, 1, 2), {
+    marks: E,
+    vertices: b,
+    subjects: y,
+    positions: r.subarray(0, l * 2),
+    links: f.subarray(0, u * 2),
+    categories: R,
+    sizes: A
   };
 }
-function X(t, e) {
-  var r;
+function V(t, e) {
+  var o;
   const n = t == null ? void 0 : t.numRows;
   if (typeof n == "number") return n;
-  const s = (r = t == null ? void 0 : t.getChild) == null ? void 0 : r.call(t, e);
+  const s = (o = t == null ? void 0 : t.getChild) == null ? void 0 : o.call(t, e);
   return s ? s.length : Array.from(t).length;
 }
-function I(t, e) {
-  const n = t.split(`
-`).find((s) => s.startsWith(`${e}:`));
-  return n == null ? void 0 : n.slice(e.length + 1).trim().replace(/^['"]|['"]$/g, "");
-}
-function Z(t, e) {
-  const n = t.split(`
-`), s = n.findIndex((i) => i.startsWith(`${e}:`));
-  if (s < 0) return [];
-  const r = [];
-  for (const i of n.slice(s + 1)) {
-    if (!i.startsWith("- ")) break;
-    r.push(i.slice(2).trim());
-  }
-  return r;
-}
-async function P(t, e) {
-  const n = await fetch(`${t}/${e}`);
-  if (!n.ok) throw new Error(`corpus: ${e} is not readable (${n.status})`);
-  return n.text();
+async function ft(t) {
+  const e = await fetch(t);
+  if (!e.ok) throw new Error(`corpus: ${t} is not readable (${e.status})`);
+  return e.text();
 }
-async function Tt(t) {
-  const { coordinator: e, dest: n, filterBy: s, subjects: r = !1, vertexType: i } = t, c = et(e, s), l = nt(c.meta), E = it(c), y = await P(n, "graph.graph.yml"), p = Z(y, "vertices"), x = Z(y, "edges"), f = await Promise.all(p.map((a) => P(n, a))), N = i === void 0 ? f[0] : f.find((a) => I(a, "type") === i);
-  if (!N)
-    throw new Error(
-      `corpus: no vertex type ${i ?? "(none declared)"} in ${n}/graph.graph.yml`
-    );
-  const $ = I(N, "type"), O = I(N, "prefix"), g = Number(I(N, "chunk_size"));
-  if (!$ || !O || !Number.isFinite(g) || g <= 0)
-    throw new Error(`corpus: ${n} declares no usable type, prefix and chunk_size`);
-  const A = (await Promise.all(x.map((a) => P(n, a)))).find((a) => I(a, "src_type") === $), u = A ? I(A, "prefix") : void 0;
-  let D = null, G;
-  const j = (a) => `'${n}/${O}chunk${a}.parquet'`, ct = (a) => `'${n}/${u}by_source/tile${a}.parquet'`, lt = async () => {
-    var o;
-    const a = (o = e.databaseConnector) == null ? void 0 : o.call(e);
+async function gt(t) {
+  var z;
+  const { coordinator: e, dest: n, filterBy: s, readText: o = ft, subjects: r = !1, vertexType: l, wasmUrl: m } = t, E = Et(e, s), h = dt(E.meta), b = St(E), R = await at(n, { readText: o, wasmUrl: m }), y = R.vertexType(l), A = R.incident(y.type).find((a) => a.srcType === y.type), x = (A == null ? void 0 : A.adjacency("src")) ?? null;
+  let f = null;
+  const u = async () => {
+    var i;
+    const a = (i = e.databaseConnector) == null ? void 0 : i.call(e);
     if (!(a != null && a.getDuckDB)) return null;
     try {
       return await a.getDuckDB();
     } catch {
       return null;
     }
-  }, U = /* @__PURE__ */ new Map();
-  let z = 0;
-  const ut = 64 * 1024 * 1024, dt = 256 * 1024;
-  async function V(a, o) {
-    const d = a === "vertex" ? j : ct, C = await lt();
-    if (!C) return o.map(d);
-    const v = await Promise.all(
-      o.map(async (m) => {
-        const S = `corpus_${$}_${a}_${m}.parquet`;
-        if (U.has(S)) return S;
-        const b = d(m).slice(1, -1), w = await fetch(b, { method: "HEAD" }), T = Number(w.headers.get("content-length"));
-        if (!w.ok || !Number.isFinite(T) || T > dt) return d(m);
-        const _ = await fetch(b);
-        if (!_.ok) return d(m);
-        const R = new Uint8Array(await _.arrayBuffer());
-        return await C.registerFileBuffer(S, R), U.set(S, R.byteLength), z += R.byteLength, S;
+  }, p = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map();
+  let F = 0;
+  const K = 64 * 1024 * 1024, Q = 256 * 1024;
+  async function j(a) {
+    if (a.length === 0) return [];
+    const i = await u();
+    if (!i) return a.map((c) => `'${c}'`);
+    const d = await Promise.all(
+      a.map(async (c) => {
+        const $ = I.get(c);
+        if ($ !== void 0 && ($.startsWith("'") || p.has($)))
+          return $;
+        const L = `corpus_${c.replace(/[^A-Za-z0-9]+/g, "_")}`, T = await fetch(c, { method: "HEAD" }), S = Number(T.headers.get("content-length"));
+        if (!T.ok || !Number.isFinite(S) || S > Q) {
+          const g = `'${c}'`;
+          return I.set(c, g), g;
+        }
+        const O = await fetch(c);
+        if (!O.ok) return `'${c}'`;
+        const N = new Uint8Array(await O.arrayBuffer());
+        return await i.registerFileBuffer(L, N), p.set(L, N.byteLength), I.set(c, L), F += N.byteLength, L;
       })
     );
-    for (; z > ut && U.size > 0; ) {
-      const [m, S] = U.entries().next().value;
-      if (v.includes(m)) break;
-      U.delete(m), z -= S, await C.dropFile(m);
+    for (; F > K && p.size > 0; ) {
+      const [c, $] = p.entries().next().value;
+      if (d.includes(c)) break;
+      p.delete(c), F -= $, await i.dropFile(c);
     }
-    return v.map((m) => m.startsWith("'") ? m : `'${m}'`);
+    return d.map((c) => c.startsWith("'") ? c : `'${c}'`);
   }
-  function H() {
-    return D ?? (D = (async () => {
-      const a = async (h) => (await fetch(`${n}/${O}chunk${h}.parquet`, { method: "HEAD" })).ok;
-      if (!await a(0)) throw new Error(`corpus: ${n}/${O} holds no chunk0`);
-      let o = 0, d = 1;
-      for (; await a(d); )
-        o = d, d *= 2;
-      for (; d - o > 1; ) {
-        const h = Math.floor((o + d) / 2);
-        await a(h) ? o = h : d = h;
-      }
-      const C = o + 1, v = await l(
-        `SELECT num_rows AS n FROM parquet_file_metadata('${j(o).slice(1, -1)}')`
-      );
-      G = o * g + Number(k(v, "n")[0] ?? 0);
-      const m = Array.from({ length: C }, (h, L) => j(L)).join(", "), S = await l(
-        `SELECT CAST(regexp_extract(file_name, 'chunk(\\d+)', 1) AS INTEGER) AS tile,
-           min(CASE WHEN path_in_schema = 'x' THEN coalesce(stats_min_value, stats_min)::DOUBLE END) AS x0,
-           max(CASE WHEN path_in_schema = 'x' THEN coalesce(stats_max_value, stats_max)::DOUBLE END) AS x1,
-           min(CASE WHEN path_in_schema = 'y' THEN coalesce(stats_min_value, stats_min)::DOUBLE END) AS y0,
-           max(CASE WHEN path_in_schema = 'y' THEN coalesce(stats_max_value, stats_max)::DOUBLE END) AS y1
-         FROM parquet_metadata([${m}])
-         WHERE path_in_schema IN ('x', 'y') GROUP BY 1 ORDER BY 1`
-      ), b = k(S, "tile"), [w, T, _, R] = ["x0", "x1", "y0", "y1"].map((h) => k(S, h));
-      return b.map((h, L) => ({
-        tile: h,
-        x0: w == null ? void 0 : w[L],
-        x1: T == null ? void 0 : T[L],
-        y0: _ == null ? void 0 : _[L],
-        y1: R == null ? void 0 : R[L]
+  const H = y.files(), M = (a) => a.map((i) => `'${i.replace(/'/g, "''")}'`).join(", ");
+  function B() {
+    return f ?? (f = (async () => {
+      const a = M(H), [i, d] = k, c = R.container === "rowgroups" ? "row_group_id" : `list_position([${a}], file_name) - 1`, $ = await h(
+        `SELECT ${c} AS tile,
+           min(CASE WHEN path_in_schema = '${i}' THEN coalesce(stats_min_value, stats_min)::DOUBLE END) AS x0,
+           max(CASE WHEN path_in_schema = '${i}' THEN coalesce(stats_max_value, stats_max)::DOUBLE END) AS x1,
+           min(CASE WHEN path_in_schema = '${d}' THEN coalesce(stats_min_value, stats_min)::DOUBLE END) AS y0,
+           max(CASE WHEN path_in_schema = '${d}' THEN coalesce(stats_max_value, stats_max)::DOUBLE END) AS y1
+         FROM parquet_metadata([${a}])
+         WHERE path_in_schema IN ('${i}', '${d}') GROUP BY 1 ORDER BY 1`
+      ), L = C($, "tile"), [T, S, O, N] = ["x0", "x1", "y0", "y1"].map((g) => C($, g));
+      return L.map((g, w) => ({
+        tile: g,
+        x0: T == null ? void 0 : T[w],
+        x1: S == null ? void 0 : S[w],
+        y0: O == null ? void 0 : O[w],
+        y1: N == null ? void 0 : N[w]
       }));
-    })()), D;
+    })()), f;
   }
-  function Et(a, o) {
-    return a.filter((d) => d.x1 >= o.xMin && d.x0 <= o.xMax && d.y1 >= o.yMin && d.y0 <= o.yMax).map((d) => d.tile);
+  function tt(a, i) {
+    return a.filter((d) => d.x1 >= i.xMin && d.x0 <= i.xMax && d.y1 >= i.yMin && d.y0 <= i.yMax).map((d) => d.tile);
   }
-  const J = {
-    id: "dense_id",
-    subject: r ? "subject" : void 0,
-    x: "x",
-    y: "y",
-    source: "src_dense",
-    target: "dst_dense"
-  }, Y = `corpus_${$}`, B = u ? `corpus_${$}_edges` : void 0, mt = async () => (await H()).map((o) => j(o.tile)).join(", ");
+  const W = {
+    id: ot[0],
+    subject: r ? it[0] : void 0,
+    x: k[0],
+    y: k[1],
+    source: (x == null ? void 0 : x.column) ?? "src_dense",
+    target: ((z = A == null ? void 0 : A.adjacency("dst")) == null ? void 0 : z.column) ?? "dst_dense"
+  }, D = `corpus_${y.type}`, U = x ? `corpus_${y.type}_edges` : void 0;
   return await e.exec(
-    `CREATE OR REPLACE VIEW ${Y} AS SELECT * FROM read_parquet([${await mt()}])`
-  ), B && await e.exec(
-    `CREATE OR REPLACE VIEW ${B} AS
-         SELECT * FROM read_parquet('${n}/${u}by_source.parquet')`
+    `CREATE OR REPLACE VIEW ${D} AS SELECT * FROM read_parquet([${M(H)}])`
+  ), U && A && await e.exec(
+    `CREATE OR REPLACE VIEW ${U} AS
+         SELECT * FROM read_parquet([${M(A.projectionFiles(1, "src"))}])`
   ), { source: {
-    ...E.api,
+    ...b.api,
     publish(a) {
-      ot(c, s, J.id, a);
+      Nt(E, s, W.id, a);
     },
+    /**
+     * How many vertices there are — **read, not probed.**
+     *
+     * The manifest declares `vertex_count`. What stood here was a note saying no manifest carries
+     * it, and a doubling-then-bisecting `HEAD` search for the last chunk plus a
+     * `parquet_file_metadata` read of its row count — about a dozen requests and a query, per
+     * corpus, for a number already in hand.
+     */
     async total() {
-      return await H(), G ?? 0;
+      if (y.count !== null) return Number(y.count);
+      const a = await h(`SELECT count(*) AS n FROM ${D}`);
+      return Number(C(a, "n")[0] ?? 0);
     },
     async extent() {
-      const a = await H();
+      const a = await B();
       return {
-        xMin: Math.min(...a.map((o) => o.x0)),
-        yMin: Math.min(...a.map((o) => o.y0)),
-        xMax: Math.max(...a.map((o) => o.x1)),
-        yMax: Math.max(...a.map((o) => o.y1))
+        xMin: Math.min(...a.map((i) => i.x0)),
+        yMin: Math.min(...a.map((i) => i.y0)),
+        xMax: Math.max(...a.map((i) => i.x1)),
+        yMax: Math.max(...a.map((i) => i.y1))
       };
     },
-    // Regions only, said the same way `duckBoundedSource` says it: no `explore`. A neighbourhood
-    // needs adjacency this source does not index, and fossil's `expand` is what answers it —
-    // `ExploringSource` is the shape waiting for whoever writes that one.
+    // Regions only, and it says so by being the only method there is. A neighbourhood needs
+    // adjacency this source does not index; `ExploringSource` declared the second question here and
+    // was deleted with it — `index.test.ts` carries why, and fossil's `expand` is what answers it.
     async slice(a) {
-      const { fill: o, limit: d, minLinkPixels: C, perPixel: v, pinned: m, r: S, signal: b, view: w } = a, T = { ...J, category: o, size: S }, _ = await H(), R = Et(_, w);
-      if (R.length === 0)
+      const { fill: i, limit: d, minLinkPixels: c, perPixel: $, pinned: L, r: T, signal: S, view: O } = a, N = { ...W, category: i, size: T }, g = await B(), w = tt(g, O);
+      if (w.length === 0)
         return {
           n: 0,
           marks: 0,
@@ -393,20 +323,21 @@ async function Tt(t) {
           links: new Float32Array(0),
           categories: new Uint16Array(0)
         };
-      const [h, L] = await Promise.all([
-        V("vertex", R),
-        V("edge", u ? R : [])
+      const G = R.tilesFor({
+        type: y.type,
+        tiles: w,
+        directions: ["src"]
+      }), [et, P] = await Promise.all([
+        j(G.vertexUrls),
+        j(G.edgeUrls)
       ]);
-      if (b != null && b.aborted) throw b.reason;
-      const K = `read_parquet([${h.join(", ")}])`, yt = `read_parquet([${L.join(", ")}])`;
-      return E.run(
-        rt(K, yt, T, w, d, 0, m, v, C, K)
-      );
+      if (S != null && S.aborted) throw S.reason;
+      const nt = `read_parquet([${et.join(", ")}])`, st = P.length > 0 ? `read_parquet([${P.join(", ")}])` : `(SELECT NULL::BIGINT AS ${N.source}, NULL::BIGINT AS ${N.target} WHERE FALSE)`;
+      return b.run($t(nt, st, N, O, d, L, $, c));
     }
-  }, nodes: Y, edges: B };
+  }, nodes: D, edges: U };
 }
 export {
-  wt as duckBoundedSource,
-  Tt as openCorpus
+  gt as openCorpus
 };
 //# sourceMappingURL=duck-source.js.map