@kanzo-tech/graph 0.1.0

package/dist/css-color.d.ts

@@ -0,0 +1,11 @@
+export type Rgba = [number, number, number, number];
+/**
+ * Any theme colour — a `var(--token)` or a literal — as GPU floats, resolved against `host`.
+ *
+ * `host` matters and is not ceremony: resolving against the element the canvas actually sits in is
+ * what lets a scoped theme override win, which resolving against `<html>` would quietly lose.
+ */
+export declare function resolveToken(host: Element, value: string, fallback?: Rgba): Rgba;
+/** cosmos.gl's *config* colours go through d3-color, so they have to be hex. */
+export declare function toHex([r, g, b, a]: Rgba): string;
+//# sourceMappingURL=css-color.d.ts.map

package/dist/css-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-color.d.ts","sourceRoot":"","sources":["../src/css-color.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AA0BpD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,IAAe,GAAG,IAAI,CAK1F;AAOD,gFAAgF;AAChF,wBAAgB,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAEhD"}

package/dist/css-color.js

@@ -0,0 +1,23 @@
+import { resolveTokenColor as u } from "@kanzo-tech/ui";
+const a = [0.7, 0.7, 0.7, 1], p = /(-?[\d.]+)/g;
+function d(r, n) {
+  var c;
+  const t = (c = r.match(p)) == null ? void 0 : c.map(Number);
+  if (!t || t.length < 3 || t.some(Number.isNaN)) return n;
+  const [o = 0, s = 0, i = 0, m = 1] = t;
+  return [o / 255, s / 255, i / 255, m];
+}
+function g(r, n, t = a) {
+  if (typeof document > "u" || !n) return t;
+  const o = n.trim().replace(/^var\(\s*|\s*\)$/g, ""), s = u(r, o.startsWith("--") ? o : n);
+  return d(s, t);
+}
+const e = (r) => Math.round(Math.min(1, Math.max(0, r)) * 255).toString(16).padStart(2, "0");
+function h([r, n, t, o]) {
+  return `#${e(r)}${e(n)}${e(t)}${o >= 1 ? "" : e(o)}`;
+}
+export {
+  g as resolveToken,
+  h as toHex
+};
+//# sourceMappingURL=css-color.js.map

package/dist/css-color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-color.js","sources":["../src/css-color.ts"],"sourcesContent":["// Theme colours as numbers a WebGL renderer can take.\n//\n// Resolution is the library's — `resolveTokenColor` from `@kanzo-tech/ui`. This file used\n// to carry its own: a 1×1 canvas painted with the colour and read back through `getImageData`. Two\n// implementations of one job, in two packages, sharing nothing and failing differently, for the\n// same underlying reason — the theme is written in `oklch()` and `color-mix()`, cosmos.gl resolves\n// through d3-color and Observable Plot through its own `isColor`, and neither knows either syntax.\n// One browser probe, one place.\n//\n// What stays here is the part that is genuinely the graph's: the library answers `rgb(r, g, b)`\n// because that is what Plot eats, and `setPointColors` wants four floats in 0..1.\n\nimport { resolveTokenColor } from \"@kanzo-tech/ui\";\n\nexport type Rgba = [number, number, number, number];\n\n/**\n * What a point wears when there is no token to resolve — not a colour this package chose.\n *\n * It cannot be `var(--muted-foreground)`: this is the path taken precisely when the token layer is\n * unreachable — `document` is undefined (a server render), or the browser handed back something\n * `parseRgb` could not read. Pointing it at another token would be pointing at the thing that just\n * failed to answer.\n *\n * So it is a mid grey, and mid is the whole of the reasoning: 0.7 sits between the light page and\n * the dark one, so a point wearing it is visible against either rather than invisible against one.\n * It is a *nothing-resolved* signal, and if it ever reaches a real screen that is a bug in the\n * caller's `host`, not a colour to tune.\n */\nconst FALLBACK: Rgba = [0.7, 0.7, 0.7, 1];\nconst CHANNELS = /(-?[\\d.]+)/g;\n\n/** `rgb(37, 99, 235)` / `rgba(37, 99, 235, 0.5)` → four floats. */\nfunction parseRgb(css: string, fallback: Rgba): Rgba {\n  const parts = css.match(CHANNELS)?.map(Number);\n  if (!parts || parts.length < 3 || parts.some(Number.isNaN)) return fallback;\n  const [r = 0, g = 0, b = 0, a = 1] = parts;\n  return [r / 255, g / 255, b / 255, a];\n}\n\n/**\n * Any theme colour — a `var(--token)` or a literal — as GPU floats, resolved against `host`.\n *\n * `host` matters and is not ceremony: resolving against the element the canvas actually sits in is\n * what lets a scoped theme override win, which resolving against `<html>` would quietly lose.\n */\nexport function resolveToken(host: Element, value: string, fallback: Rgba = FALLBACK): Rgba {\n  if (typeof document === \"undefined\" || !value) return fallback;\n  const token = value.trim().replace(/^var\\(\\s*|\\s*\\)$/g, \"\");\n  const resolved = resolveTokenColor(host, token.startsWith(\"--\") ? token : value);\n  return parseRgb(resolved, fallback);\n}\n\nconst byte = (n: number) =>\n  Math.round(Math.min(1, Math.max(0, n)) * 255)\n    .toString(16)\n    .padStart(2, \"0\");\n\n/** cosmos.gl's *config* colours go through d3-color, so they have to be hex. */\nexport function toHex([r, g, b, a]: Rgba): string {\n  return `#${byte(r)}${byte(g)}${byte(b)}${a >= 1 ? \"\" : byte(a)}`;\n}\n"],"names":["FALLBACK","CHANNELS","parseRgb","css","fallback","parts","_a","r","g","b","a","resolveToken","host","value","token","resolved","resolveTokenColor","byte","n","toHex"],"mappings":";AA6BA,MAAMA,IAAiB,CAAC,KAAK,KAAK,KAAK,CAAC,GAClCC,IAAW;AAGjB,SAASC,EAASC,GAAaC,GAAsB;;AACnD,QAAMC,KAAQC,IAAAH,EAAI,MAAMF,CAAQ,MAAlB,gBAAAK,EAAqB,IAAI;AACvC,MAAI,CAACD,KAASA,EAAM,SAAS,KAAKA,EAAM,KAAK,OAAO,KAAK,EAAG,QAAOD;AACnE,QAAM,CAACG,IAAI,GAAGC,IAAI,GAAGC,IAAI,GAAGC,IAAI,CAAC,IAAIL;AACrC,SAAO,CAACE,IAAI,KAAKC,IAAI,KAAKC,IAAI,KAAKC,CAAC;AACtC;AAQO,SAASC,EAAaC,GAAeC,GAAeT,IAAiBJ,GAAgB;AAC1F,MAAI,OAAO,WAAa,OAAe,CAACa,EAAO,QAAOT;AACtD,QAAMU,IAAQD,EAAM,KAAA,EAAO,QAAQ,qBAAqB,EAAE,GACpDE,IAAWC,EAAkBJ,GAAME,EAAM,WAAW,IAAI,IAAIA,IAAQD,CAAK;AAC/E,SAAOX,EAASa,GAAUX,CAAQ;AACpC;AAEA,MAAMa,IAAO,CAACC,MACZ,KAAK,MAAM,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGA,CAAC,CAAC,IAAI,GAAG,EACzC,SAAS,EAAE,EACX,SAAS,GAAG,GAAG;AAGb,SAASC,EAAM,CAAC,GAAGX,GAAGC,GAAGC,CAAC,GAAiB;AAChD,SAAO,IAAIO,EAAK,CAAC,CAAC,GAAGA,EAAKT,CAAC,CAAC,GAAGS,EAAKR,CAAC,CAAC,GAAGC,KAAK,IAAI,KAAKO,EAAKP,CAAC,CAAC;AAChE;"}

package/dist/duck-source.d.ts

@@ -0,0 +1,182 @@
+import { Coordinator, Selection } from '@kanzo-tech/mosaic';
+import { BoundedSource } from './bounded';
+import { VertexId } from './resident';
+/**
+ * A `BoundedSource` over two ordinary relations in DuckDB.
+ *
+ * On a subpath because Mosaic is an optional peer and this is the half that needs it: a host drawing
+ * arrays it already holds takes `memorySource` and pays for no database. Splitting them is what lets
+ * that promise be true rather than merely stated.
+ *
+ * **Neutral about storage, and that is the point.** The neutrality let bounded be measured against
+ * unbounded before anything committed to a layout on disk — and it is the reason this file survived
+ * a decision on the other side of the seam. The verb it was written to sit beside never landed:
+ * `viewport` was dropped and GraphAr with it, because the camera is addressed rather than queried.
+ * What replaces it is a tile fetched by a computed URL, which is another source.
+ *
+ * **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;
+}
+export interface DuckSourceOptions {
+    coordinator: Coordinator;
+    /**
+     * The crossfilter this graph draws inside.
+     *
+     * Given, the page's predicate rides in the slice query and the canvas draws **what survives**.
+     * Omitted, the source is a reader of a relation and nothing else — which is what a graph with no
+     * charts beside it is.
+     */
+    filterBy?: Selection;
+    /** The node relation. */
+    nodes: string;
+    /** The edge relation, as pairs of node ids. */
+    edges: string;
+    /**
+     * Which vertex type this relation is.
+     *
+     * Required, and with no default, because the source is the only thing that knows: a `dense_id`
+     * numbers within one type, so the identity a slice carries is only completed here. A corpus of one
+     * type is type `0` and has to say so — a defaulted `0` would let a second relation ship the same
+     * identities as the first with nothing raised.
+     */
+    typeIndex: number;
+    /**
+     * A **dense** integer id — `0..n-1`, no gaps.
+     *
+     * Dense because `links` refers to positions rather than to ids, so a consumer never pays for an
+     * id→index map. GraphAr's `dense_id` is this column by another name.
+     */
+    idField?: string;
+    /**
+     * The identity column — the subject IRI. **Omitted, a slice carries addresses only.**
+     *
+     * A `dense_id` says where a vertex is; the IRI says which vertex it is, and only the second
+     * survives the layout being redone. The corpus writes it as `subject`, non-null and unique within
+     * a type, which is why that is the name here — but it stays opt-in rather than defaulted, because
+     * reading it costs 1.87× the drawing tile and most points are painted rather than named.
+     *
+     * Set it when something outlives a session: a bookmark, a link out, a selection that has to mean
+     * the same thing after the next `fossil run`.
+     */
+    subjectField?: string;
+    xField?: string;
+    yField?: string;
+    /**
+     * **What colours and what sizes are not here**, and their absence is the shape rather than an
+     * omission: they are `fill` and `r` on the request, because a channel is what the caller wants
+     * drawn now and this object is where the bytes are. Given here too, recolouring meant building a
+     * second source — and two places deciding one colour is the state that move ended.
+     */
+    sourceField?: string;
+    targetField?: string;
+}
+export declare function duckBoundedSource(options: DuckSourceOptions): DuckSource;
+/**
+ * A corpus that fossil wrote, read by address.
+ *
+ * **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 knows one thing: **where the corpus is.**
+ *
+ * ```ts
+ * const { source } = await openCorpus({ coordinator, dest: "/bench/1000000" });
+ * ```
+ *
+ * **Addressed, not queried.** The manifest 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: a corpus reader that also accepts `idField` is `duckBoundedSource` with extra
+ * steps, and there is already one of those for the case this is not — an arbitrary relation with
+ * `x`/`y` that nobody wrote as a corpus.
+ */
+export interface OpenCorpusOptions {
+    coordinator: 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;
+    /** Where the corpus lives, without a trailing slash — the directory holding `graph.graph.yml`. */
+    dest: string;
+    /**
+     * 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 opening a corpus registers views for it.
+ *
+ * This is the other side's own shape. `fossil-mcp` describes itself as opening a dataset,
+ * *registering views over the Parquet the corpus already holds*, and dispatching a verb — the same
+ * two halves, named the same way, one call apart.
+ */
+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, registered and ready to query by name.
+     *
+     * 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 relation, or `undefined` when the corpus declares no edge for this type. */
+    edges: string | undefined;
+}
+export declare function openCorpus(options: OpenCorpusOptions): Promise<OpenedCorpus>;
+//# sourceMappingURL=duck-source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duck-source.d.ts","sourceRoot":"","sources":["../src/duck-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAc,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAgC,KAAK,aAAa,EAAgD,MAAM,WAAW,CAAC;AAE3H,OAAO,EAA6B,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;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;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAuFD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,GAAG,UAAU,CAmExE;AAmdD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,kGAAkG;IAClG,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAyCD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;OAOG;IACH,MAAM,EAAE,UAAU,CAAC;IACnB;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,uGAAuG;IACvG,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CA+WlF"}

package/dist/duck-source.js

@@ -0,0 +1,413 @@
+"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) {
+  return {
+    points: new z(t, e),
+    links: new z(t, e),
+    meta: new z(t)
+  };
+}
+function et(t) {
+  let e = Promise.resolve();
+  return (n) => {
+    const s = e.then(() => t.ask(() => n));
+    return e = s.catch(() => {
+    }), s;
+  };
+}
+function K(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) {
+  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 = {
+    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);
+  return {
+    ...S.api,
+    publish(y) {
+      it(l, s, c.id, y);
+    },
+    async total() {
+      const y = await m(`SELECT count(*) AS n FROM ${i}`);
+      return Number(k(y, "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 y = await m(
+        `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") };
+    },
+    /**
+     * 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(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)
+      );
+    }
+  };
+}
+function ht(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}`);
+  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";
+  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` : ""},
+           count(*) OVER () AS matched
+    FROM ${t}
+    WHERE ${n}
+  ), vis AS (
+    SELECT id, x, y${e.size ? ", size" : ""}${e.subject ? ", subject" : ""}${i ? ", matched" : ""},
+           ${l},
+           (row_number() OVER (ORDER BY id) - 1)::INTEGER AS local
+    FROM pool
+    WHERE id % ${ft(s)} = 0
+    LIMIT ${s}
+  )`;
+}
+function st(t, e, n) {
+  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}`;
+}
+function Nt(t, e, n, s, i, r) {
+  const c = nt(`NOT (${s})`, i), l = st("a", "b", r);
+  return `, out AS (
+    SELECT ${n.id} AS id, ${n.x} AS x, ${n.y} AS y FROM ${t} WHERE ${c}
+  ), 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
+    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)${l ? ` AND ${l}` : ""}
+  ), 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 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) : "";
+  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: (u) => `${W(t, n, h(u), i)}${L(u)}
+       SELECT local, id, x, y, category, matched, TRUE AS mark${x}${g} FROM vis${m ? `
+       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 — or, where nothing is held, both ends drawn.
+     *
+     * 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.
+     */
+    links: (u) => m ? `${W(t, n, h(u), i, !1)}${L(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)}
+        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) => ({
+      /**
+       * 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(k(u, "matched")[0] ?? 0),
+      ...gt(u, C, r, n.size ? "size" : void 0, n.subject !== void 0)
+    })
+  };
+}
+function rt(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));
+  };
+  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(r) {
+        return n = r, t.points.onAnswer = i("points"), t.links.onAnswer = i("links"), () => {
+          n = null, s.clear(), e = null, t.points.release(), t.links.release(), t.meta.release();
+        };
+      }
+    },
+    async run(r) {
+      e = r, s.clear();
+      const [c, l] = await Promise.all([
+        t.points.ask(r.points),
+        t.links.ask(r.links)
+      ]);
+      return r.assemble(c, l);
+    }
+  };
+}
+function it(t, e, n, s) {
+  e && e.update(
+    yt([n], s == null ? void 0 : s.map((i) => [Z(i)]), {
+      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,
+    positions: c.subarray(0, l * 2),
+    links: f.subarray(0, L * 2),
+    categories: A,
+    sizes: x
+  };
+}
+function Q(t, e) {
+  var i;
+  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);
+  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 X(t, e) {
+  const n = t.split(`
+`), s = n.findIndex((r) => r.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());
+  }
+  return i;
+}
+async function q(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)
+    throw new Error(
+      `corpus: no vertex type ${r ?? "(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)
+    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 () => {
+    var o;
+    const a = (o = e.databaseConnector) == null ? void 0 : o.call(e);
+    if (!(a != null && a.getDuckDB)) return null;
+    try {
+      return await a.getDuckDB();
+    } catch {
+      return null;
+    }
+  }, D = /* @__PURE__ */ new Map();
+  let H = 0;
+  const lt = 64 * 1024 * 1024, ut = 256 * 1024;
+  async function V(a, o) {
+    const d = a === "vertex" ? U : ot, M = await ct();
+    if (!M) 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, $;
+      })
+    );
+    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);
+    }
+    return v.map((E) => E.startsWith("'") ? E : `'${E}'`);
+  }
+  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`);
+      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 M = o + 1, v = await l(
+        `SELECT num_rows AS n FROM parquet_file_metadata('${U(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(
+        `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}])
+         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]
+      }));
+    })()), P;
+  }
+  function dt(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,
+    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(", ");
+  return await e.exec(
+    `CREATE OR REPLACE VIEW ${Y} AS SELECT * FROM read_parquet([${await Et()}])`
+  ), B && await e.exec(
+    `CREATE OR REPLACE VIEW ${B} AS
+         SELECT * FROM read_parquet('${n}/${C}by_source.parquet')`
+  ), { source: {
+    ...m.api,
+    publish(a) {
+      it(c, s, J.id, a);
+    },
+    async total() {
+      return await j(), G ?? 0;
+    },
+    async extent() {
+      const a = await j();
+      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, perPixel: M, pinned: v, r: E, signal: $, view: F } = a, w = { ...J, category: o, size: E }, T = await j(), R = dt(T, F);
+      if (R.length === 0)
+        return {
+          n: 0,
+          marks: 0,
+          vertices: new BigUint64Array(0),
+          positions: new Float32Array(0),
+          links: new Float32Array(0),
+          categories: new Uint16Array(0)
+        };
+      const [O, N] = await Promise.all([
+        V("vertex", R),
+        V("edge", C ? 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)
+      );
+    }
+  }, nodes: Y, edges: B };
+}
+export {
+  _t as duckBoundedSource,
+  Lt as openCorpus
+};
+//# sourceMappingURL=duck-source.js.map