@kanzo-tech/graph 0.10.0 → 0.12.0

package/dist/duck-source.d.ts

@@ -1,198 +0,0 @@
-import { Corpus, GapReason } from '@fossil-lang/corpus';
-import { Engine, Selection } from '@kanzo-tech/mosaic';
-import { BoundedSource } from './bounded';
-import { VertexId } from './resident';
-/**
- * The source: a corpus fossil wrote, read through DuckDB.
- *
- * On a subpath because Mosaic and fossil's reader are optional peers and this is the half that needs
- * them. The root barrel ships no source at all, which is the whole of what that split now means: a
- * host that installs neither gets the rendering surface and draws nothing.
- *
- * **There used to be two here and the second was neutral about storage.** `duckBoundedSource` took
- * two ordinary relations and the column names that made sense of them, and that neutrality earned
- * its keep once — it let bounded be measured against unbounded before anything committed to a layout
- * on disk. What it cost afterwards is the reason it is gone: a corpus already declares those names
- * in its manifest, so the second source was this side writing down what the other side owns, and the
- * two answered the same question in two dialects of the same SQL.
- *
- * **Every query in this file goes through a `SliceRead`, and there is no other path.** `onceQuery`
- * was the other one — a throwaway client per query, on this subpath, re-exported for the two
- * showcases that also read a relation directly. It is gone: a read the page's filters cannot reach
- * is a picture that disagrees with the page, and `slice-client.ts` carries what that cost.
- */
-/**
- * A DuckDB-backed source, and the one thing it can do that the render contract knows nothing about.
- *
- * `BoundedSource` says what a renderer needs: answer a bounded question. Publishing a selection is
- * the other direction of the same seam and it is Mosaic's, not the renderer's — so it lives on the
- * concrete type rather than on the contract, beside `watch`, which is on the contract because the
- * query loop is what has to act on it.
- */
-export interface DuckSource extends BoundedSource {
-    /**
-     * The reader's own selection, as a clause the rest of the page filters by. `null` retracts it.
-     *
-     * **The graph is exempt from its own clause, and that is the whole difference from the greyout it
-     * replaces.** While the canvas *faded* excluded rows it could take its own clause too — the row was
-     * still drawn and still selectable, and the fade was the brush. A canvas that now draws what
-     * survives would answer a lasso by deleting everything the reader did not lasso, which is not a
-     * selection, it is a filter nobody asked for.
-     */
-    publish(vertices: readonly VertexId[] | null): void;
-}
-/**
- * A corpus that fossil wrote, read by address — **and the addressing is fossil's.**
- *
- * **The five things a call site used to know, and now does not.** Drawing a corpus meant deriving
- * the chunk URLs from a `chunk_size` copied by hand, knowing how a tile is named, knowing what the
- * edge directory is called, knowing GraphAr's column names, and knowing that a glob cannot work over
- * a plain HTTP origin because there is no listing. Five conventions and about forty lines, none of
- * it the business of something that wants to draw a graph. `/docs/design/graph` carries the
- * argument; the copied `chunk_size` carries the evidence, because it went stale and read
- * a fraction of a corpus in silence for as long as it did.
- *
- * The consumer holds two things: **the corpus fossil opened, and the page's engine.**
- *
- * ```ts
- * const e = await engine();
- * const corpus = await open("/bench/1000000", { query: e.query });
- * const { source } = await openCorpus({ corpus, engine: e });
- * ```
- *
- * **And this side no longer knows the conventions either, which is the change.** It used to remove
- * that defect for its callers by committing it one level down — a YAML line-scanner, a
- * `chunk{k}.parquet` spelling, a `by_source/tile{k}.parquet` spelling and a `HEAD`-probing search
- * for a tile count — and by the time those were deleted all four were **wrong**: fossil writes
- * `container: rowgroups`, one `tiles.parquet` whose row groups are the tiles, and `vertex_count`
- * had been in the manifest the whole time the search was probing for it. Fossil's `open` is
- * `fossil_graph::plan` compiled to wasm32: the arithmetic the native reader runs, not a second
- * implementation of it that agrees until it does not.
- *
- * **Addressed, not queried.** The manifests and the per-tile boxes are read once and kept; after
- * that a camera move is arithmetic over boxes and a list of URLs. There is deliberately no request
- * on the path between the camera moving and a URL being computable — the moment there is one, this
- * has become the `viewport` verb fossil deleted.
- *
- * **What it is not.** It takes no column names and no type index. Those come from the manifest or
- * they do not come. There used to be a second source here for the case this is not — an arbitrary
- * relation with `x`/`y` that nobody wrote as a corpus — and taking `idField` here would have been
- * that one with extra steps. It is gone, so the rule is simpler than the guard against it: a column
- * name reaching this door is a name the manifest should have carried.
- */
-export interface OpenCorpusOptions {
-    /**
-     * The corpus, as fossil's `open` answered it — **opened by the host, and once.**
-     *
-     * This door used to open one itself from a `dest`, a `readText` and a `wasm`, which made it the
-     * third open of the same corpus on a keasy discover visit: the host had already opened it to
-     * query it, and opened it again only so that this could. Opening is the host's, because what it
-     * takes is the host's — where the corpus is, and what signs it. Drawing takes the result.
-     */
-    corpus: Corpus;
-    /**
-     * The page's engine — `engine()` from `@kanzo-tech/mosaic`. The canvas reads its tiles and
-     * publishes its clauses through the coordinator; the files are the ones the corpus already made
-     * readable, by the names its addressing gives them.
-     */
-    engine: Pick<Engine, "coordinator">;
-    /**
-     * The crossfilter this graph draws inside — the same `Selection` the page's charts filter by.
-     *
-     * Given, the predicate rides in the slice query and the canvas draws what survives.
-     */
-    filterBy?: Selection;
-    /**
-     * Which vertex type to draw, when a corpus carries more than one.
-     *
-     * Defaults to the first the manifest names. A corpus of one type never passes it; a corpus of
-     * several has to, because *which graph do you mean* is not a question a reader can answer.
-     */
-    vertexType?: string;
-    /**
-     * Read the identity column as well. **Off by default, and the same trade as everywhere else:**
-     * `subject` costs about twice the drawing tile, so the drawing path carries addresses and a host
-     * asks for names when something has to be *named* rather than painted.
-     */
-    subjects?: boolean;
-}
-/**
- * An opened corpus: the half that **draws** and the half that **answers**.
- *
- * A host needs both over the same bytes and they are not the same access. The canvas reads tiles by
- * address — a handful of files per camera move, chosen from the footer's boxes, with no query. A
- * chart, a crossfilter clause or a verb reads the *relation*: every row, by column name, in SQL.
- * Hiding the URLs behind `source` is right for the first and leaves the second with nothing to
- * query, so this hands on the names fossil's verbs already query the corpus by.
- */
-export interface OpenedCorpus {
-    /**
-     * For the canvas: `<GraphCanvas source={…}>`. Reads tiles, never the whole relation.
-     *
-     * A `DuckSource`, and `CorpusSource` is gone with the reason it existed: `extent()` was declared
-     * there because a source over an unlaid-out relation has no answer to it, and *optional on the
-     * base contract* says that better than a second interface — a relation with `x`/`y` has an extent
-     * too, and it was the one host that could not frame its opening view.
-     */
-    source: DuckSource;
-    /**
-     * The vertex relation, as fossil registered it — qualified by the corpus's catalog.
-     *
-     * Every column the manifest declares, including the corpus' own properties — so a clause a chart
-     * publishes over `kind` or `region` lands here with no translation, which is what makes one
-     * crossfilter serve the canvas and the charts.
-     */
-    nodes: string;
-    /**
-     * The source-ordered edge relations this canvas draws, one fossil relation each.
-     *
-     * **A list, because a corpus declares a list.** This was one name, picked with `.find` over the
-     * relations whose source is this type — so a corpus declaring two edge labels registered the
-     * first and dropped the second with nothing raised, and a chart over `corpus_Person_edges` was a
-     * chart over half the graph. `frame` on the other side takes every one of them
-     * (`packages/corpus/src/corpus.ts`, `edges.filter((e) => e.srcType === address.type)`), and
-     * fossil's own `verbs()` registers a view per relation under `{src}_{edge}_{dst}` rather than
-     * unioning them — which is also what keeps two relations' differing property columns from having
-     * to agree on one schema.
-     *
-     * Empty when the corpus declares no relation this source can draw; {@link OpenedCorpus.undrawn}
-     * is then where the ones it declared went.
-     */
-    edges: readonly EdgeRelation[];
-    /**
-     * The relations incident to this type that the canvas does **not** read, and why.
-     *
-     * A single-type canvas can draw a relation only where *both* endpoints are numbered in its own
-     * `dense_id` space. The rest are dropped from the read rather than mixed into it, and reported
-     * here rather than dropped in silence.
-     */
-    undrawn: readonly UndrawnRelation[];
-}
-/** One edge relation of the drawn type, and the relation fossil registered its adjacency as. */
-export interface EdgeRelation {
-    readonly edgeType: string;
-    readonly srcType: string;
-    readonly dstType: string;
-    /** Fossil's relation, qualified by the corpus's catalog — its `CorpusRelation.sql`. */
-    readonly view: string;
-}
-/**
- * One relation incident to the drawn type that this source cannot read, and why.
- *
- * **The reason is fossil's {@link GapReason} and not a second spelling of it** — `other-space` when
- * an endpoint is another vertex type, so the `dense_id` on that side numbers a different set of
- * vertices and this source holds no coordinates for any of them; `not-declared` when both endpoints
- * are this type and the corpus publishes no source-ordered adjacency to read. The two the drawing
- * read can produce; the third, `not-requested`, is `tilesFor`'s and never reaches here.
- *
- * What this adds to a `Gap` is the endpoint pair, which a `Gap` does not carry: it names a relation
- * by label and orientation, and a corpus may declare two relations under one label.
- */
-export interface UndrawnRelation {
-    readonly edgeType: string;
-    readonly srcType: string;
-    readonly dstType: string;
-    readonly reason: GapReason;
-}
-export declare function openCorpus(options: OpenCorpusOptions): Promise<OpenedCorpus>;
-//# sourceMappingURL=duck-source.d.ts.map

package/dist/duck-source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"duck-source.d.ts","sourceRoot":"","sources":["../src/duck-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,MAAM,EAGN,SAAS,EAEV,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAe,MAAM,EAAc,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAiC,MAAM,WAAW,CAAC;AAE9E,OAAO,EAA6B,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtE;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;CACrD;AAojBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAkBD;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;OAOG;IACH,MAAM,EAAE,UAAU,CAAC;IACnB;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;;;;;;;;OAcG;IACH,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/B;;;;;;OAMG;IACH,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;CACrC;AAED,gGAAgG;AAChG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CA8SlF"}

package/dist/duck-source.js

@@ -1,320 +0,0 @@
-"use client";
-import { PAYLOAD_COORDINATES as M, PAYLOAD_IDENTITY as te, PAYLOAD_ADDRESS as ne } from "@fossil-lang/corpus";
-import { numbers as b, clausePoints as se, fillColumn as x, column as oe } from "@kanzo-tech/mosaic";
-import { SliceRead as F } from "./slice-client.js";
-import { typeOf as ae, denseOf as G, vertexId as ie } from "./resident.js";
-const q = 0;
-function re(e, t) {
-  return {
-    points: new F(e, t),
-    links: new F(e, t),
-    meta: new F(e)
-  };
-}
-function ce(e) {
-  let t = Promise.resolve();
-  return (n) => {
-    const o = t.then(() => e.ask(() => n));
-    return t = o.catch(() => {
-    }), o;
-  };
-}
-function z(e) {
-  if (e == null) return "";
-  const n = (Array.isArray(e) ? e : [e]).filter((o) => o != null).map((o) => String(o));
-  return n.length > 0 ? n.map((o) => `(${o})`).join(" AND ") : "";
-}
-function P(e, t) {
-  return e ? t ? `(${e}) AND (${t})` : e : t || "TRUE";
-}
-function le(e, t) {
-  const o = [
-    [e.x, t.xMin, ">="],
-    [e.x, t.xMax, "<="],
-    [e.y, t.yMin, ">="],
-    [e.y, t.yMax, "<="]
-  ].filter(([, i]) => Number.isFinite(i)).map(([i, c, r]) => `${i} ${r} ${c}`);
-  return o.length > 0 ? o.join(" AND ") : "TRUE";
-}
-const ue = (e) => `greatest(1, CAST(ceil(matched / ${e}.0) AS BIGINT))`;
-function W(e, t, n, o, i = !0) {
-  const c = t.size ? `, ${t.size} AS size` : "", r = t.subject ? `, ${t.subject} AS subject` : "", u = t.category ? "(dense_rank() OVER (ORDER BY cat) - 1)::INTEGER AS category" : "0::INTEGER AS category";
-  return `WITH pool AS (
-    SELECT ${t.id} AS id, ${t.x} AS x, ${t.y} AS y${c}${r}${t.category ? `, ${t.category} AS cat` : ""},
-           count(*) OVER () AS matched
-    FROM ${e}
-    WHERE ${n}
-  ), vis AS (
-    SELECT id, x, y${t.size ? ", size" : ""}${t.subject ? ", subject" : ""}${i ? ", matched" : ""},
-           ${u},
-           (row_number() OVER (ORDER BY id) - 1)::INTEGER AS local
-    FROM pool
-    WHERE id % ${ue(o)} = 0
-    LIMIT ${o}
-  )`;
-}
-function de(e, t, n, o) {
-  if (n === void 0 || !Number.isFinite(n) || n <= 0) return "";
-  const i = o * n;
-  return `(${e}.x - ${t}.x) * (${e}.x - ${t}.x) + (${e}.y - ${t}.y) * (${e}.y - ${t}.y) >= ${i * i}`;
-}
-function Ee(e, t, n, o, i, c, r) {
-  const u = P(`NOT (${o})`, i), E = de("a", "b", c, r);
-  return `, out AS (
-    SELECT ${n.id} AS id, ${n.x} AS x, ${n.y} AS y FROM ${e} WHERE ${u}
-  ), 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 ${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
-    LEFT JOIN vis tv ON tv.id = b.id
-    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
-    FROM out o
-    WHERE o.id IN (SELECT src_id FROM span WHERE src IS NULL
-                   UNION SELECT dst_id FROM span WHERE dst IS NULL)
-  )`;
-}
-function ye(e, t, n, o, i, c, r, u) {
-  const E = le(n, o), S = (c ?? []).filter((l) => ae(l) === q).map(G), y = S.length > 0 ? ` OR ${n.id} IN (${S.join(",")})` : "", m = `(${E})${y}`, $ = (l) => P(m, z(l)), T = n.size ? ", size" : "", f = n.subject ? ", subject" : "", A = (l) => Ee(e, t, n, m, z(l), r, u);
-  return {
-    /**
-     * The marks, then the anchors, in one answer — because they are one buffer.
-     *
-     * `ORDER BY local` is load-bearing rather than tidy: `local` runs `0..marks-1` over the sample
-     * 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: (l) => `${W(e, n, $(l), i)}${A(l)}
-       SELECT local, id, x, y, category, matched, TRUE AS mark${T}${f} 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
-       ORDER BY local`,
-    /**
-     * One end drawn and both ends positioned.
-     *
-     * 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: (l) => `${W(e, n, $(l), i, !1)}${A(l)}
-        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`,
-    assemble: (l, p) => ({
-      /**
-       * How many matched, separately from how many came back.
-       *
-       * Without it the view cannot tell a reader "there is more here than I am showing you", and a
-       * truncated slice looks exactly like a complete one — which is the failure this whole branch
-       * 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(b(l, "matched")[0] ?? 0),
-      ...Ae(l, p, n.size ? "size" : void 0, n.subject !== void 0)
-    })
-  };
-}
-function pe(e) {
-  let t = null, n = null;
-  const o = /* @__PURE__ */ new Map(), i = (c) => (r) => {
-    if (!t || !n || (o.set(c, r), o.size < 2)) return;
-    const u = o.get("points"), E = o.get("links");
-    o.clear(), n(t.assemble(u, E));
-  };
-  return {
-    api: {
-      /**
-       * Say when the answer changes for a reason the camera cannot see.
-       *
-       * The reason it hands over a whole `Slice` rather than a nudge to ask again: the coordinator
-       * 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(c) {
-        return n = c, e.points.onAnswer = i("points"), e.links.onAnswer = i("links"), () => {
-          n = null, o.clear(), t = null, e.points.release(), e.links.release(), e.meta.release();
-        };
-      }
-    },
-    async run(c) {
-      t = c, o.clear();
-      const [r, u] = await Promise.all([
-        e.points.ask(c.points),
-        e.links.ask(c.links)
-      ]);
-      return c.assemble(r, u);
-    }
-  };
-}
-function me(e, t, n, o) {
-  t && t.update(
-    se([n], o == null ? void 0 : o.map((i) => [G(i)]), {
-      source: e.points,
-      clients: /* @__PURE__ */ new Set([e.points, e.links])
-    })
-  );
-}
-function Ae(e, t, n, o = !1) {
-  const i = Y(e, "x"), c = new Float32Array(i * 2), r = x(e, "x", c, 0, 2);
-  x(e, "y", c, 1, 2);
-  const u = new Int32Array(i);
-  x(e, "mark", u);
-  let E = 0;
-  for (; E < r && u[E] !== 0; ) E++;
-  const S = new Float64Array(r);
-  x(e, "id", S);
-  const y = new BigUint64Array(r);
-  for (let p = 0; p < r; p++) y[p] = ie(q, S[p]);
-  const m = new Uint16Array(r);
-  x(e, "category", m);
-  const $ = o ? oe(e, "subject") : void 0;
-  let T;
-  n && (T = new Float32Array(r), x(e, n, T));
-  const f = Y(t, "src"), A = new Float32Array(f * 2), l = x(t, "src", A, 0, 2);
-  return x(t, "dst", A, 1, 2), {
-    marks: E,
-    vertices: y,
-    subjects: $,
-    positions: c.subarray(0, r * 2),
-    links: A.subarray(0, l * 2),
-    categories: m,
-    sizes: T
-  };
-}
-function Y(e, t) {
-  var i;
-  const n = e == null ? void 0 : e.numRows;
-  if (typeof n == "number") return n;
-  const o = (i = e == null ? void 0 : e.getChild) == null ? void 0 : i.call(e, t);
-  return o ? o.length : Array.from(e).length;
-}
-async function xe(e) {
-  var D, j, H;
-  const { corpus: t, engine: n, filterBy: o, subjects: i = !1, vertexType: c } = e, { addressing: r } = t, u = re(n.coordinator, o), E = ce(u.meta), S = pe(u), y = r.vertexType(c), m = r.drawing(y.type), $ = m.relations.map((s) => ({
-    address: s,
-    // Never null on a drawn relation: a declared source-ordered adjacency is what `drawing` admits
-    // one for, and `not-declared` is why the others are in `undrawn` instead.
-    adjacency: s.adjacency("src")
-  })), T = $.map((s) => s.adjacency), f = r.incident(y.type).filter((s) => !m.relations.includes(s)).map((s, a) => ({
-    edgeType: s.edgeType,
-    srcType: s.srcType,
-    dstType: s.dstType,
-    reason: m.undrawn[a].reason
-  }));
-  let A = null;
-  const l = y.files(), p = (s) => s.map((a) => `'${a.replace(/'/g, "''")}'`).join(", ");
-  function w() {
-    return A ?? (A = (async () => {
-      const s = p(l), [a, d] = M, I = r.container === "rowgroups" ? "row_group_id" : `list_position([${s}], file_name) - 1`, _ = await E(
-        `SELECT ${I} AS tile,
-           min(CASE WHEN path_in_schema = '${a}' THEN coalesce(stats_min_value, stats_min)::DOUBLE END) AS x0,
-           max(CASE WHEN path_in_schema = '${a}' 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([${s}])
-         WHERE path_in_schema IN ('${a}', '${d}') GROUP BY 1 ORDER BY 1`
-      ), C = b(_, "tile"), [g, N, L, R] = ["x0", "x1", "y0", "y1"].map((h) => b(_, h));
-      return C.map((h, O) => ({
-        tile: h,
-        x0: g == null ? void 0 : g[O],
-        x1: N == null ? void 0 : N[O],
-        y0: L == null ? void 0 : L[O],
-        y1: R == null ? void 0 : R[O]
-      }));
-    })()), A;
-  }
-  function V(s, a) {
-    return s.filter((d) => d.x1 >= a.xMin && d.x0 <= a.xMax && d.y1 >= a.yMin && d.y0 <= a.yMax).map((d) => d.tile);
-  }
-  const U = {
-    id: ne[0],
-    subject: i ? te[0] : void 0,
-    x: M[0],
-    y: M[1],
-    source: ((D = T[0]) == null ? void 0 : D.column) ?? "src_dense",
-    target: ((H = (j = $[0]) == null ? void 0 : j.address.adjacency("dst")) == null ? void 0 : H.column) ?? "dst_dense"
-  }, J = await t.relations(), v = (s, a) => {
-    const d = J.find(s);
-    if (!d) throw new Error(`openCorpus: the corpus registers no relation for ${a}`);
-    return d.sql;
-  }, k = v((s) => s.kind === "vertex" && s.name === y.type, y.type);
-  return {
-    source: {
-      ...S.api,
-      publish(s) {
-        me(u, o, U.id, s);
-      },
-      /**
-       * 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 s = await E(`SELECT count(*) AS n FROM ${k}`);
-        return Number(b(s, "n")[0] ?? 0);
-      },
-      async extent() {
-        const s = await w();
-        return {
-          xMin: Math.min(...s.map((a) => a.x0)),
-          yMin: Math.min(...s.map((a) => a.y0)),
-          xMax: Math.max(...s.map((a) => a.x1)),
-          yMax: Math.max(...s.map((a) => a.y1))
-        };
-      },
-      // 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(s) {
-        const { fill: a, limit: d, minLinkPixels: I, perPixel: _, pinned: C, r: g, signal: N, view: L } = s, R = { ...U, category: a, size: g }, h = await w(), O = V(h, L);
-        if (O.length === 0)
-          return {
-            n: 0,
-            marks: 0,
-            vertices: new BigUint64Array(0),
-            positions: new Float32Array(0),
-            links: new Float32Array(0),
-            categories: new Uint16Array(0)
-          };
-        const X = r.tilesFor({
-          type: y.type,
-          tiles: O,
-          directions: ["src"]
-        }), B = [
-          ...new Set(T.flatMap((Z) => O.map((ee) => Z.tileUrl(ee))))
-        ];
-        if (N != null && N.aborted) throw N.reason;
-        const K = `read_parquet([${p(X.vertexUrls)}])`, Q = B.length > 0 ? `read_parquet([${p(B)}])` : `(SELECT NULL::BIGINT AS ${R.source}, NULL::BIGINT AS ${R.target} WHERE FALSE)`;
-        return S.run(ye(K, Q, R, L, d, C, _, I));
-      }
-    },
-    nodes: k,
-    edges: $.map(({ address: s }) => ({
-      edgeType: s.edgeType,
-      srcType: s.srcType,
-      dstType: s.dstType,
-      view: v(
-        (a) => a.kind === "edge" && a.edgeType === s.edgeType && a.srcType === s.srcType && a.dstType === s.dstType,
-        `${s.srcType}_${s.edgeType}_${s.dstType}`
-      )
-    })),
-    undrawn: f
-  };
-}
-export {
-  xe as openCorpus
-};
-//# sourceMappingURL=duck-source.js.map