@kanzo-tech/graph 0.2.0 → 0.4.0

package/dist/duck-source.js

@@ -1,118 +1,72 @@
 "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 le, PAYLOAD_COORDINATES as v, PAYLOAD_IDENTITY as ue, PAYLOAD_ADDRESS as de } from "@fossil-lang/corpus";
+import { numbers as I, clausePoints as Ee, fillColumn as _, column as pe } from "@kanzo-tech/mosaic";
+import { SliceRead as k } from "./slice-client.js";
+import { typeOf as ye, denseOf as X, vertexId as me } from "./resident.js";
+const Z = 0;
+function Ae(e, t) {
   return {
-    points: new W(t, e),
-    links: new W(t, e),
-    meta: new W(t)
+    points: new k(e, t),
+    links: new k(e, t),
+    meta: new k(e)
   };
 }
-function nt(t) {
-  let e = Promise.resolve();
+function $e(e) {
+  let t = Promise.resolve();
   return (n) => {
-    const s = e.then(() => t.ask(() => n));
-    return e = s.catch(() => {
+    const s = t.then(() => e.ask(() => n));
+    return t = s.catch(() => {
     }), s;
   };
 }
-function Q(t) {
-  if (t == null) return "";
-  const n = (Array.isArray(t) ? t : [t]).filter((s) => s != null).map((s) => String(s));
+function q(e) {
+  if (e == null) return "";
+  const n = (Array.isArray(e) ? e : [e]).filter((s) => s != null).map((s) => String(s));
   return n.length > 0 ? n.map((s) => `(${s})`).join(" AND ") : "";
 }
-function st(t, e) {
-  return t ? e ? `(${t}) AND (${e})` : t : e || "TRUE";
+function K(e, t) {
+  return e ? t ? `(${e}) AND (${t})` : e : t || "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 Se(e, t) {
   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}`);
+    [e.x, t.xMin, ">="],
+    [e.x, t.xMax, "<="],
+    [e.y, t.yMin, ">="],
+    [e.y, t.yMax, "<="]
+  ].filter(([, a]) => Number.isFinite(a)).map(([a, i, c]) => `${a} ${c} ${i}`);
   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 fe = (e) => `greatest(1, CAST(ceil(matched / ${e}.0) AS BIGINT))`;
+function V(e, t, n, s, a = !0) {
+  const i = t.size ? `, ${t.size} AS size` : "", c = t.subject ? `, ${t.subject} AS subject` : "", p = t.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 ${t.id} AS id, ${t.x} AS x, ${t.y} AS y${i}${c}${t.category ? `, ${t.category} AS cat` : ""},
            count(*) OVER () AS matched
-    FROM ${t}
+    FROM ${e}
     WHERE ${n}
   ), vis AS (
-    SELECT id, x, y${e.size ? ", size" : ""}${e.subject ? ", subject" : ""}${r ? ", matched" : ""},
-           ${l},
+    SELECT id, x, y${t.size ? ", size" : ""}${t.subject ? ", subject" : ""}${a ? ", matched" : ""},
+           ${p},
            (row_number() OVER (ORDER BY id) - 1)::INTEGER AS local
     FROM pool
-    WHERE id % ${ht(s)} = 0
+    WHERE id % ${fe(s)} = 0
     LIMIT ${s}
   )`;
 }
-function at(t, e, n, s) {
+function Te(e, t, 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 a = s * n;
+  return `(${e}.x - ${t}.x) * (${e}.x - ${t}.x) + (${e}.y - ${t}.y) * (${e}.y - ${t}.y) >= ${a * a}`;
 }
-function ft(t, e, n, s, r, i, c) {
-  const l = st(`NOT (${s})`, r), E = at("a", "b", i, c);
+function Ne(e, t, n, s, a, i, c) {
+  const p = K(`NOT (${s})`, a), E = Te("a", "b", i, c);
   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 ${e} WHERE ${p}
   ), reach AS (
     SELECT id, x, y FROM vis UNION ALL SELECT id, x, y FROM out
   ), span AS (
     SELECT sv.local AS src, tv.local AS dst, a.id AS src_id, b.id AS dst_id
-    FROM ${e} e
+    FROM ${t} e
     JOIN reach a ON e.${n.source} = a.id
     JOIN reach b ON e.${n.target} = b.id
     LEFT JOIN vis sv ON sv.id = a.id
@@ -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 he(e, t, n, s, a, i, c, p) {
+  const E = Se(n, s), h = (i ?? []).filter((u) => ye(u) === Z).map(X), b = h.length > 0 ? ` OR ${n.id} IN (${h.join(",")})` : "", S = `(${E})${b}`, y = (u) => K(S, q(u)), f = n.size ? ", size" : "", w = n.subject ? ", subject" : "", T = (u) => Ne(e, t, n, S, q(u), c, p);
   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) => `${V(e, n, y(u), a)}${T(u)}
+       SELECT local, id, x, y, category, matched, TRUE AS mark${f}${w} 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) => `${V(e, n, y(u), a, !1)}${T(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, R) => ({
       /**
        * 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(I(u, "matched")[0] ?? 0),
+      ...xe(u, R, n.size ? "size" : void 0, n.subject !== void 0)
     })
   };
 }
-function it(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));
+function Re(e) {
+  let t = null, n = null;
+  const s = /* @__PURE__ */ new Map(), a = (i) => (c) => {
+    if (!t || !n || (s.set(i, c), s.size < 2)) return;
+    const p = s.get("points"), E = s.get("links");
+    s.clear(), n(t.assemble(p, E));
   };
   return {
     api: {
@@ -190,223 +140,241 @@ function it(t) {
        * 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"), () => {
-          n = null, s.clear(), e = null, t.points.release(), t.links.release(), t.meta.release();
+        return n = i, e.points.onAnswer = a("points"), e.links.onAnswer = a("links"), () => {
+          n = null, s.clear(), t = null, e.points.release(), e.links.release(), e.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)
+      t = i, s.clear();
+      const [c, p] = await Promise.all([
+        e.points.ask(i.points),
+        e.links.ask(i.links)
       ]);
-      return i.assemble(c, l);
+      return i.assemble(c, p);
     }
   };
 }
-function ot(t, e, n, s) {
-  e && e.update(
-    $t([n], s == null ? void 0 : s.map((r) => [tt(r)]), {
-      source: t.points,
-      clients: /* @__PURE__ */ new Set([t.points, t.links])
+function Oe(e, t, n, s) {
+  t && t.update(
+    Ee([n], s == null ? void 0 : s.map((a) => [X(a)]), {
+      source: e.points,
+      clients: /* @__PURE__ */ new Set([e.points, e.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 xe(e, t, n, s = !1) {
+  const a = J(e, "x"), i = new Float32Array(a * 2), c = _(e, "x", i, 0, 2);
+  _(e, "y", i, 1, 2);
+  const p = new Int32Array(a);
+  _(e, "mark", p);
+  let E = 0;
+  for (; E < c && p[E] !== 0; ) E++;
+  const h = new Float64Array(c);
+  _(e, "id", h);
+  const b = new BigUint64Array(c);
+  for (let R = 0; R < c; R++) b[R] = me(Z, h[R]);
+  const S = new Uint16Array(c);
+  _(e, "category", S);
+  const y = s ? pe(e, "subject") : void 0;
+  let f;
+  n && (f = new Float32Array(c), _(e, n, f));
+  const w = J(t, "src"), T = new Float32Array(w * 2), u = _(t, "src", T, 0, 2);
+  return _(t, "dst", T, 1, 2), {
+    marks: E,
+    vertices: b,
+    subjects: y,
+    positions: i.subarray(0, c * 2),
+    links: T.subarray(0, u * 2),
+    categories: S,
+    sizes: f
   };
 }
-function X(t, e) {
-  var r;
-  const n = t == null ? void 0 : t.numRows;
+function J(e, t) {
+  var a;
+  const n = e == null ? void 0 : e.numRows;
   if (typeof n == "number") return n;
-  const s = (r = t == null ? void 0 : t.getChild) == null ? void 0 : r.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, "");
+  const s = (a = e == null ? void 0 : e.getChild) == null ? void 0 : a.call(e, t);
+  return s ? s.length : Array.from(e).length;
 }
-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());
+function Le(e, t) {
+  const n = [], s = [];
+  for (const a of e) {
+    const i = { edgeType: a.edgeType, srcType: a.srcType, dstType: a.dstType };
+    if (a.srcType !== t || a.dstType !== t) {
+      s.push({ ...i, reason: "other-space" });
+      continue;
+    }
+    const c = a.adjacency("src");
+    if (c === null) {
+      s.push({ ...i, reason: "not-declared" });
+      continue;
+    }
+    n.push({
+      ...i,
+      address: a,
+      adjacency: c,
+      view: `corpus_${a.srcType}_${a.edgeType}_${a.dstType}`
+    });
   }
-  return r;
+  return { drawn: n, undrawn: s };
 }
-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 ge(e) {
+  const t = await fetch(e);
+  if (!t.ok) throw new Error(`corpus: ${e} is not readable (${t.status})`);
+  return t.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);
-    if (!(a != null && a.getDuckDB)) return null;
+async function Fe(e) {
+  var z, G, P;
+  const { coordinator: t, dest: n, filterBy: s, readText: a = ge, subjects: i = !1, vertexType: c, wasmUrl: p } = e, E = Ae(t, s), h = $e(E.meta), b = Re(E), S = await le(n, { readText: a, wasmUrl: p }), y = S.vertexType(c), { drawn: f, undrawn: w } = Le(S.incident(y.type), y.type), T = f.map((o) => o.adjacency);
+  let u = null;
+  const R = async () => {
+    var r;
+    const o = (r = t.databaseConnector) == null ? void 0 : r.call(t);
+    if (!(o != null && o.getDuckDB)) return null;
     try {
-      return await a.getDuckDB();
+      return await o.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;
+  }, C = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map();
+  let M = 0;
+  const Q = 64 * 1024 * 1024, ee = 256 * 1024;
+  async function j(o) {
+    if (o.length === 0) return [];
+    const r = await R();
+    if (!r) return o.map((l) => `'${l}'`);
+    const d = await Promise.all(
+      o.map(async (l) => {
+        const m = F.get(l);
+        if (m !== void 0 && (m.startsWith("'") || C.has(m)))
+          return m;
+        const O = `corpus_${l.replace(/[^A-Za-z0-9]+/g, "_")}`, x = await fetch(l, { method: "HEAD" }), A = Number(x.headers.get("content-length"));
+        if (!x.ok || !Number.isFinite(A) || A > ee) {
+          const L = `'${l}'`;
+          return F.set(l, L), L;
+        }
+        const N = await fetch(l);
+        if (!N.ok) return `'${l}'`;
+        const $ = new Uint8Array(await N.arrayBuffer());
+        return await r.registerFileBuffer(O, $), C.set(O, $.byteLength), F.set(l, O), M += $.byteLength, O;
       })
     );
-    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 (; M > Q && C.size > 0; ) {
+      const [l, m] = C.entries().next().value;
+      if (d.includes(l)) break;
+      C.delete(l), M -= m, await r.dropFile(l);
     }
-    return v.map((m) => m.startsWith("'") ? m : `'${m}'`);
+    return d.map((l) => l.startsWith("'") ? l : `'${l}'`);
   }
-  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(), D = (o) => o.map((r) => `'${r.replace(/'/g, "''")}'`).join(", ");
+  function B() {
+    return u ?? (u = (async () => {
+      const o = D(H), [r, d] = v, l = S.container === "rowgroups" ? "row_group_id" : `list_position([${o}], file_name) - 1`, m = await h(
+        `SELECT ${l} AS tile,
+           min(CASE WHEN path_in_schema = '${r}' THEN coalesce(stats_min_value, stats_min)::DOUBLE END) AS x0,
+           max(CASE WHEN path_in_schema = '${r}' 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([${o}])
+         WHERE path_in_schema IN ('${r}', '${d}') GROUP BY 1 ORDER BY 1`
+      ), O = I(m, "tile"), [x, A, N, $] = ["x0", "x1", "y0", "y1"].map((L) => I(m, L));
+      return O.map((L, g) => ({
+        tile: L,
+        x0: x == null ? void 0 : x[g],
+        x1: A == null ? void 0 : A[g],
+        y0: N == null ? void 0 : N[g],
+        y1: $ == null ? void 0 : $[g]
       }));
-    })()), D;
+    })()), u;
   }
-  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 te(o, r) {
+    return o.filter((d) => d.x1 >= r.xMin && d.x0 <= r.xMax && d.y1 >= r.yMin && d.y0 <= r.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(", ");
-  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')`
-  ), { source: {
-    ...E.api,
-    publish(a) {
-      ot(c, s, J.id, a);
-    },
-    async total() {
-      return await H(), G ?? 0;
-    },
-    async extent() {
-      const a = await H();
-      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))
-      };
-    },
-    // 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.
-    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 W = {
+    id: de[0],
+    subject: i ? ue[0] : void 0,
+    x: v[0],
+    y: v[1],
+    source: ((z = T[0]) == null ? void 0 : z.column) ?? "src_dense",
+    target: ((P = (G = f[0]) == null ? void 0 : G.address.adjacency("dst")) == null ? void 0 : P.column) ?? "dst_dense"
+  }, U = `corpus_${y.type}`;
+  await t.exec(
+    `CREATE OR REPLACE VIEW ${U} AS SELECT * FROM read_parquet([${D(H)}])`
+  );
+  for (const o of f)
+    await t.exec(
+      `CREATE OR REPLACE VIEW ${o.view} AS
+         SELECT * FROM read_parquet([${D(o.address.projectionFiles(1, "src"))}])`
+    );
+  return {
+    source: {
+      ...b.api,
+      publish(o) {
+        Oe(E, s, W.id, o);
+      },
+      /**
+       * 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() {
+        if (y.count !== null) return Number(y.count);
+        const o = await h(`SELECT count(*) AS n FROM ${U}`);
+        return Number(I(o, "n")[0] ?? 0);
+      },
+      async extent() {
+        const o = await B();
         return {
-          n: 0,
-          marks: 0,
-          vertices: new BigUint64Array(0),
-          positions: new Float32Array(0),
-          links: new Float32Array(0),
-          categories: new Uint16Array(0)
+          xMin: Math.min(...o.map((r) => r.x0)),
+          yMin: Math.min(...o.map((r) => r.y0)),
+          xMax: Math.max(...o.map((r) => r.x1)),
+          yMax: Math.max(...o.map((r) => r.y1))
         };
-      const [h, L] = await Promise.all([
-        V("vertex", R),
-        V("edge", u ? R : [])
-      ]);
-      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)
-      );
-    }
-  }, nodes: Y, edges: B };
+      },
+      // 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(o) {
+        const { fill: r, limit: d, minLinkPixels: l, perPixel: m, pinned: O, r: x, signal: A, view: N } = o, $ = { ...W, category: r, size: x }, L = await B(), g = te(L, N);
+        if (g.length === 0)
+          return {
+            n: 0,
+            marks: 0,
+            vertices: new BigUint64Array(0),
+            positions: new Float32Array(0),
+            links: new Float32Array(0),
+            categories: new Uint16Array(0)
+          };
+        const ne = S.tilesFor({
+          type: y.type,
+          tiles: g,
+          directions: ["src"]
+        }), se = [
+          ...new Set(T.flatMap((ie) => g.map((ce) => ie.tileUrl(ce))))
+        ], [ae, Y] = await Promise.all([
+          j(ne.vertexUrls),
+          j(se)
+        ]);
+        if (A != null && A.aborted) throw A.reason;
+        const oe = `read_parquet([${ae.join(", ")}])`, re = Y.length > 0 ? `read_parquet([${Y.join(", ")}])` : `(SELECT NULL::BIGINT AS ${$.source}, NULL::BIGINT AS ${$.target} WHERE FALSE)`;
+        return b.run(he(oe, re, $, N, d, O, m, l));
+      }
+    },
+    nodes: U,
+    edges: f.map(({ edgeType: o, srcType: r, dstType: d, view: l }) => ({
+      edgeType: o,
+      srcType: r,
+      dstType: d,
+      view: l
+    })),
+    undrawn: w
+  };
 }
 export {
-  wt as duckBoundedSource,
-  Tt as openCorpus
+  Fe as openCorpus
 };
 //# sourceMappingURL=duck-source.js.map