@kanzo-tech/graph 0.1.0 → 0.2.0

package/dist/duck-source.js

@@ -1,16 +1,15 @@
 "use client";
-import { numbers as k, clausePoints as yt, fillColumn as _, column as $t } from "@kanzo-tech/mosaic";
-import { SUPERSEDED as pt, BOUNDED_DEFAULTS as xt } from "./bounded.js";
-import { SliceRead as z } from "./slice-client.js";
-import { typeOf as St, denseOf as Z, vertexId as At } from "./resident.js";
-function tt(t, e) {
+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) {
   return {
-    points: new z(t, e),
-    links: new z(t, e),
-    meta: new z(t)
+    points: new W(t, e),
+    links: new W(t, e),
+    meta: new W(t)
   };
 }
-function et(t) {
+function nt(t) {
   let e = Promise.resolve();
   return (n) => {
     const s = e.then(() => t.ask(() => n));
@@ -18,31 +17,31 @@ function et(t) {
     }), s;
   };
 }
-function K(t) {
+function Q(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 nt(t, e) {
+function st(t, e) {
   return t ? e ? `(${t}) AND (${e})` : t : e || "TRUE";
 }
-function _t(t) {
-  const { coordinator: e, edges: n, filterBy: s, nodes: i, typeIndex: r } = t, c = {
+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 = tt(e, s), m = et(l.meta), S = rt(l);
+  }, l = et(e, s), E = nt(l.meta), y = it(l);
   return {
-    ...S.api,
-    publish(y) {
-      it(l, s, c.id, y);
+    ...y.api,
+    publish(p) {
+      ot(l, s, c.id, p);
     },
     async total() {
-      const y = await m(`SELECT count(*) AS n FROM ${i}`);
-      return Number(k(y, "n")[0] ?? 0);
+      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.
@@ -51,12 +50,12 @@ function _t(t) {
      * default box and finds the corpus occupying a corner of it.
      */
     async extent() {
-      const y = await m(
+      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 ${i}`
-      ), p = (A) => Number(k(y, A)[0] ?? 0);
-      return { xMin: p("x0"), yMin: p("y0"), xMax: p("x1"), yMax: p("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`.
@@ -66,49 +65,49 @@ function _t(t) {
      * 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(y) {
-      const { fill: p, limit: A, perPixel: h, pinned: x, r: g, view: f } = y, L = { ...c, category: p, size: g };
-      return S.run(
-        at(i, n, L, f, A, r, x, h, void 0)
+    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 ht(t, e) {
+function St(t, e) {
   const s = [
     [t.x, e.xMin, ">="],
     [t.x, e.xMax, "<="],
     [t.y, e.yMin, ">="],
     [t.y, e.yMax, "<="]
-  ].filter(([, i]) => Number.isFinite(i)).map(([i, r, c]) => `${i} ${c} ${r}`);
+  ].filter(([, r]) => Number.isFinite(r)).map(([r, i, c]) => `${r} ${c} ${i}`);
   return s.length > 0 ? s.join(" AND ") : "TRUE";
 }
-const ft = (t) => `greatest(1, CAST(ceil(matched / ${t}.0) AS BIGINT))`;
-function W(t, e, n, s, i = !0) {
-  const r = 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 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";
   return `WITH pool AS (
-    SELECT ${e.id} AS id, ${e.x} AS x, ${e.y} AS y${r}${c}${e.category ? `, ${e.category} AS cat` : ""},
+    SELECT ${e.id} AS id, ${e.x} AS x, ${e.y} AS y${i}${c}${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" : ""}${i ? ", matched" : ""},
+    SELECT id, x, y${e.size ? ", size" : ""}${e.subject ? ", subject" : ""}${r ? ", matched" : ""},
            ${l},
            (row_number() OVER (ORDER BY id) - 1)::INTEGER AS local
     FROM pool
-    WHERE id % ${ft(s)} = 0
+    WHERE id % ${ht(s)} = 0
     LIMIT ${s}
   )`;
 }
-function st(t, e, n) {
+function at(t, e, n, s) {
   if (n === void 0 || !Number.isFinite(n) || n <= 0) return "";
-  const s = xt.minLinkPixels * n;
-  return `(${t}.x - ${e}.x) * (${t}.x - ${e}.x) + (${t}.y - ${e}.y) * (${t}.y - ${e}.y) >= ${s * s}`;
+  const r = s * n;
+  return `(${t}.x - ${e}.x) * (${t}.x - ${e}.x) + (${t}.y - ${e}.y) * (${t}.y - ${e}.y) >= ${r * r}`;
 }
-function Nt(t, e, n, s, i, r) {
-  const c = nt(`NOT (${s})`, i), l = st("a", "b", r);
+function ft(t, e, n, s, r, i, c) {
+  const l = st(`NOT (${s})`, r), E = at("a", "b", i, c);
   return `, out AS (
-    SELECT ${n.id} AS id, ${n.x} AS x, ${n.y} AS y FROM ${t} WHERE ${c}
+    SELECT ${n.id} AS id, ${n.x} AS x, ${n.y} AS y FROM ${t} WHERE ${l}
   ), reach AS (
     SELECT id, x, y FROM vis UNION ALL SELECT id, x, y FROM out
   ), span AS (
@@ -118,7 +117,7 @@ function Nt(t, e, n, s, i, r) {
     JOIN reach b ON e.${n.target} = b.id
     LEFT JOIN vis sv ON sv.id = a.id
     LEFT JOIN vis tv ON tv.id = b.id
-    WHERE (sv.id IS NOT NULL OR tv.id IS NOT NULL)${l ? ` AND ${l}` : ""}
+    WHERE (sv.id IS NOT NULL OR tv.id IS NOT NULL)${E ? ` AND ${E}` : ""}
   ), anchor AS (
     SELECT o.id, o.x, o.y,
            ((SELECT count(*) FROM vis) + row_number() OVER (ORDER BY o.id) - 1)::INTEGER AS local
@@ -127,8 +126,8 @@ function Nt(t, e, n, s, i, r) {
                    UNION SELECT dst_id FROM span WHERE dst IS NULL)
   )`;
 }
-function at(t, e, n, s, i, r, c, l, m) {
-  const S = ht(n, s), y = (c ?? []).filter((u) => St(u) === r).map(Z), p = y.length > 0 ? ` OR ${n.id} IN (${y.join(",")})` : "", A = `(${S})${p}`, h = (u) => nt(A, K(u)), x = n.size ? ", size" : "", g = n.subject ? ", subject" : "", f = st("s", "t", l), L = (u) => m ? Nt(m, e, n, A, K(u), l) : "";
+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) : "";
   return {
     /**
      * The marks, then the anchors, in one answer — because they are one buffer.
@@ -137,8 +136,8 @@ function at(t, e, n, s, i, r, c, l, m) {
      * 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) => `${W(t, n, h(u), i)}${L(u)}
-       SELECT local, id, x, y, category, matched, TRUE AS mark${x}${g} FROM vis${m ? `
+    points: (u) => `${q(t, n, $(u), r)}${A(u)}
+       SELECT local, id, x, y, category, matched, TRUE AS mark${O}${g} FROM vis${y ? `
        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` : ""}
        ORDER BY local`,
@@ -150,17 +149,17 @@ function at(t, e, n, s, i, r, c, l, m) {
      * 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.
      */
-    links: (u) => m ? `${W(t, n, h(u), i, !1)}${L(u)}
+    links: (u) => y ? `${q(t, n, $(u), r, !1)}${A(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` : `${W(t, n, h(u), i, !1)}
+        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, C) => ({
+        JOIN vis t ON e.${n.target} = t.id${F ? `
+        WHERE ${F}` : ""}`,
+    assemble: (u, D) => ({
       /**
        * How many matched, separately from how many came back.
        *
@@ -170,16 +169,16 @@ function at(t, e, n, s, i, r, c, l, m) {
        * column, and an empty answer has no row and no matches, which agree.
        */
       n: Number(k(u, "matched")[0] ?? 0),
-      ...gt(u, C, r, n.size ? "size" : void 0, n.subject !== void 0)
+      ...Nt(u, D, i, n.size ? "size" : void 0, n.subject !== void 0)
     })
   };
 }
-function rt(t) {
+function it(t) {
   let e = null, n = null;
-  const s = /* @__PURE__ */ new Map(), i = (r) => (c) => {
-    if (!e || !n || (s.set(r, c), s.size < 2)) return;
-    const l = s.get("points"), m = s.get("links");
-    s.clear(), n(e.assemble(l, m));
+  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));
   };
   return {
     api: {
@@ -190,62 +189,62 @@ function rt(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(r) {
-        return n = r, t.points.onAnswer = i("points"), t.links.onAnswer = i("links"), () => {
+      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();
         };
       }
     },
-    async run(r) {
-      e = r, s.clear();
+    async run(i) {
+      e = i, s.clear();
       const [c, l] = await Promise.all([
-        t.points.ask(r.points),
-        t.links.ask(r.links)
+        t.points.ask(i.points),
+        t.links.ask(i.links)
       ]);
-      return r.assemble(c, l);
+      return i.assemble(c, l);
     }
   };
 }
-function it(t, e, n, s) {
+function ot(t, e, n, s) {
   e && e.update(
-    yt([n], s == null ? void 0 : s.map((i) => [Z(i)]), {
+    $t([n], s == null ? void 0 : s.map((r) => [tt(r)]), {
       source: t.points,
       clients: /* @__PURE__ */ new Set([t.points, t.links])
     })
   );
 }
-function gt(t, e, n, s, i = !1) {
-  const r = Q(t, "x"), c = new Float32Array(r * 2), l = _(t, "x", c, 0, 2);
-  _(t, "y", c, 1, 2);
-  const m = new Int32Array(r);
-  _(t, "mark", m);
-  let S = 0;
-  for (; S < l && m[S] !== 0; ) S++;
-  const y = new Float64Array(l);
-  _(t, "id", y);
-  const p = new BigUint64Array(l);
-  for (let u = 0; u < l; u++) p[u] = At(n, y[u]);
-  const A = new Uint16Array(l);
-  _(t, "category", A);
-  const h = i ? $t(t, "subject") : void 0;
-  let x;
-  s && (x = new Float32Array(l), _(t, s, x));
-  const g = Q(e, "src"), f = new Float32Array(g * 2), L = _(e, "src", f, 0, 2);
-  return _(e, "dst", f, 1, 2), {
-    marks: S,
-    vertices: p,
-    subjects: h,
+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: f.subarray(0, L * 2),
-    categories: A,
-    sizes: x
+    links: g.subarray(0, F * 2),
+    categories: f,
+    sizes: $
   };
 }
-function Q(t, e) {
-  var i;
+function X(t, e) {
+  var r;
   const n = t == null ? void 0 : t.numRows;
   if (typeof n == "number") return n;
-  const s = (i = t == null ? void 0 : t.getChild) == null ? void 0 : i.call(t, e);
+  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) {
@@ -253,34 +252,34 @@ function I(t, e) {
 `).find((s) => s.startsWith(`${e}:`));
   return n == null ? void 0 : n.slice(e.length + 1).trim().replace(/^['"]|['"]$/g, "");
 }
-function X(t, e) {
+function Z(t, e) {
   const n = t.split(`
-`), s = n.findIndex((r) => r.startsWith(`${e}:`));
+`), s = n.findIndex((i) => i.startsWith(`${e}:`));
   if (s < 0) return [];
-  const i = [];
-  for (const r of n.slice(s + 1)) {
-    if (!r.startsWith("- ")) break;
-    i.push(r.slice(2).trim());
+  const r = [];
+  for (const i of n.slice(s + 1)) {
+    if (!i.startsWith("- ")) break;
+    r.push(i.slice(2).trim());
   }
-  return i;
+  return r;
 }
-async function q(t, e) {
+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 Lt(t) {
-  const { coordinator: e, dest: n, filterBy: s, subjects: i = !1, vertexType: r } = t, c = tt(e, s), l = et(c.meta), m = rt(c), S = await q(n, "graph.graph.yml"), y = X(S, "vertices"), p = X(S, "edges"), A = await Promise.all(y.map((a) => q(n, a))), h = r === void 0 ? A[0] : A.find((a) => I(a, "type") === r);
-  if (!h)
+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 ${r ?? "(none declared)"} in ${n}/graph.graph.yml`
+      `corpus: no vertex type ${i ?? "(none declared)"} in ${n}/graph.graph.yml`
     );
-  const x = I(h, "type"), g = I(h, "prefix"), f = Number(I(h, "chunk_size"));
-  if (!x || !g || !Number.isFinite(f) || f <= 0)
+  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 u = (await Promise.all(p.map((a) => q(n, a)))).find((a) => I(a, "src_type") === x), C = u ? I(u, "prefix") : void 0;
-  let P = null, G;
-  const U = (a) => `'${n}/${g}chunk${a}.parquet'`, ot = (a) => `'${n}/${C}by_source/tile${a}.parquet'`, ct = async () => {
+  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;
@@ -289,90 +288,90 @@ async function Lt(t) {
     } catch {
       return null;
     }
-  }, D = /* @__PURE__ */ new Map();
-  let H = 0;
-  const lt = 64 * 1024 * 1024, ut = 256 * 1024;
+  }, U = /* @__PURE__ */ new Map();
+  let z = 0;
+  const ut = 64 * 1024 * 1024, dt = 256 * 1024;
   async function V(a, o) {
-    const d = a === "vertex" ? U : ot, M = await ct();
-    if (!M) return o.map(d);
+    const d = a === "vertex" ? j : ct, C = await lt();
+    if (!C) return o.map(d);
     const v = await Promise.all(
-      o.map(async (E) => {
-        const $ = `corpus_${x}_${a}_${E}.parquet`;
-        if (D.has($)) return $;
-        const F = d(E).slice(1, -1), w = await fetch(F, { method: "HEAD" }), T = Number(w.headers.get("content-length"));
-        if (!w.ok || !Number.isFinite(T) || T > ut) return d(E);
-        const R = await fetch(F);
-        if (!R.ok) return d(E);
-        const O = new Uint8Array(await R.arrayBuffer());
-        return await M.registerFileBuffer($, O), D.set($, O.byteLength), H += O.byteLength, $;
+      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;
       })
     );
-    for (; H > lt && D.size > 0; ) {
-      const [E, $] = D.entries().next().value;
-      if (v.includes(E)) break;
-      D.delete(E), H -= $, await M.dropFile(E);
+    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);
     }
-    return v.map((E) => E.startsWith("'") ? E : `'${E}'`);
+    return v.map((m) => m.startsWith("'") ? m : `'${m}'`);
   }
-  function j() {
-    return P ?? (P = (async () => {
-      const a = async (N) => (await fetch(`${n}/${g}chunk${N}.parquet`, { method: "HEAD" })).ok;
-      if (!await a(0)) throw new Error(`corpus: ${n}/${g} holds no chunk0`);
+  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 N = Math.floor((o + d) / 2);
-        await a(N) ? o = N : d = N;
+        const h = Math.floor((o + d) / 2);
+        await a(h) ? o = h : d = h;
       }
-      const M = o + 1, v = await l(
-        `SELECT num_rows AS n FROM parquet_file_metadata('${U(o).slice(1, -1)}')`
+      const C = o + 1, v = await l(
+        `SELECT num_rows AS n FROM parquet_file_metadata('${j(o).slice(1, -1)}')`
       );
-      G = o * f + Number(k(v, "n")[0] ?? 0);
-      const E = Array.from({ length: M }, (N, b) => U(b)).join(", "), $ = await l(
+      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([${E}])
+         FROM parquet_metadata([${m}])
          WHERE path_in_schema IN ('x', 'y') GROUP BY 1 ORDER BY 1`
-      ), F = k($, "tile"), [w, T, R, O] = ["x0", "x1", "y0", "y1"].map((N) => k($, N));
-      return F.map((N, b) => ({
-        tile: N,
-        x0: w == null ? void 0 : w[b],
-        x1: T == null ? void 0 : T[b],
-        y0: R == null ? void 0 : R[b],
-        y1: O == null ? void 0 : O[b]
+      ), 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]
       }));
-    })()), P;
+    })()), D;
   }
-  function dt(a, o) {
+  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);
   }
   const J = {
     id: "dense_id",
-    subject: i ? "subject" : void 0,
+    subject: r ? "subject" : void 0,
     x: "x",
     y: "y",
     source: "src_dense",
     target: "dst_dense"
-  }, Y = `corpus_${x}`, B = C ? `corpus_${x}_edges` : void 0, Et = async () => (await j()).map((o) => U(o.tile)).join(", ");
+  }, 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 Et()}])`
+    `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}/${C}by_source.parquet')`
+         SELECT * FROM read_parquet('${n}/${u}by_source.parquet')`
   ), { source: {
-    ...m.api,
+    ...E.api,
     publish(a) {
-      it(c, s, J.id, a);
+      ot(c, s, J.id, a);
     },
     async total() {
-      return await j(), G ?? 0;
+      return await H(), G ?? 0;
     },
     async extent() {
-      const a = await j();
+      const a = await H();
       return {
         xMin: Math.min(...a.map((o) => o.x0)),
         yMin: Math.min(...a.map((o) => o.y0)),
@@ -384,7 +383,7 @@ async function Lt(t) {
     // 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, perPixel: M, pinned: v, r: E, signal: $, view: F } = a, w = { ...J, category: o, size: E }, T = await j(), R = dt(T, F);
+      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)
         return {
           n: 0,
@@ -394,20 +393,20 @@ async function Lt(t) {
           links: new Float32Array(0),
           categories: new Uint16Array(0)
         };
-      const [O, N] = await Promise.all([
+      const [h, L] = await Promise.all([
         V("vertex", R),
-        V("edge", C ? R : [])
+        V("edge", u ? R : [])
       ]);
-      if ($ != null && $.aborted) throw pt;
-      const b = `read_parquet([${O.join(", ")}])`, mt = `read_parquet([${N.join(", ")}])`;
-      return m.run(
-        at(b, mt, w, F, d, 0, v, M, b)
+      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 };
 }
 export {
-  _t as duckBoundedSource,
-  Lt as openCorpus
+  wt as duckBoundedSource,
+  Tt as openCorpus
 };
 //# sourceMappingURL=duck-source.js.map