@littlebigbrain/client 0.7.0 → 0.8.1

package/dist/client.js

@@ -1,9 +1,9 @@
 import { parseSparqlResults } from "./types.js";
 import { bodyMarksTerminal, errorCodeFromBody, fullJitterBackoffMs, parseLbbError, parseResponseJson, retryAllowed, retryableStatus, retryDelayMs, sleep, } from "./transport.js";
-import { ContextNamespace, EntityNamespace, GraphNamespace, IndexNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
+import { ContextNamespace, EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
 export { parseSparqlResults } from "./types.js";
 export { LbbError } from "./transport.js";
-export { ContextNamespace, EntityNamespace, FactsNamespace, GraphNamespace, IndexNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
+export { ContextNamespace, EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
 /**
  * A typed HTTP client for a little big brain graph server. One instance is scoped to a
  * single graph/branch; construct another for a different scope. All methods
@@ -24,9 +24,10 @@ export class LbbClient {
     onRequest;
     onResponse;
     onRetry;
+    /** A5 default read consistency applied when a read omits its own value. */
+    defaultConsistency;
     context;
     search;
-    indexes;
     entities;
     schema;
     ontology;
@@ -41,7 +42,7 @@ export class LbbClient {
         this.graphName = options.graph;
         this.branchName = options.branch;
         this.stack = options.stack;
-        this.apiVersion = options.apiVersion ?? "2026-06-22";
+        this.apiVersion = options.apiVersion ?? "2026-07-23";
         this.maxRetries = options.maxRetries ?? 6;
         this.retryDelayMs = options.retryDelayMs ?? 100;
         this.retryBudgetMs = options.retryBudgetMs ?? 60_000;
@@ -49,6 +50,7 @@ export class LbbClient {
         this.onRequest = options.onRequest;
         this.onResponse = options.onResponse;
         this.onRetry = options.onRetry;
+        this.defaultConsistency = options.defaultConsistency;
         if (!Number.isInteger(this.maxRetries) || this.maxRetries < 0) {
             throw new RangeError("maxRetries must be a non-negative integer");
         }
@@ -69,7 +71,6 @@ export class LbbClient {
         this.fetchImpl = chosen;
         this.context = new ContextNamespace(this);
         this.search = new SearchNamespace(this);
-        this.indexes = new IndexNamespace(this);
         this.entities = new EntityNamespace(this);
         this.schema = new SchemaNamespace(this);
         this.ontology = new OntologyNamespace(this);
@@ -103,8 +104,38 @@ export class LbbClient {
             onRequest: this.onRequest,
             onResponse: this.onResponse,
             onRetry: this.onRetry,
+            defaultConsistency: this.defaultConsistency,
         });
     }
+    /**
+     * A5: fold read-consistency options into a request body's own `consistency` /
+     * `min_indexed_seq` fields (the shape used by full-text, embedding, and
+     * structured-SPARQL bodies). A per-call value wins over the client
+     * `defaultConsistency`; an explicit body field wins over both.
+     */
+    resolveConsistency(opts) {
+        return opts?.consistency ?? this.defaultConsistency;
+    }
+    mergeReadConsistency(body, opts) {
+        const consistency = this.resolveConsistency(opts);
+        const merged = { ...body };
+        if (consistency !== undefined && merged.consistency === undefined) {
+            merged.consistency = consistency;
+        }
+        if (opts?.minIndexedSeq !== undefined &&
+            merged.min_indexed_seq === undefined) {
+            merged.min_indexed_seq = opts.minIndexedSeq;
+        }
+        return merged;
+    }
+    /** A5: read-consistency options rendered as URL query params, for the routes
+     * that carry consistency on the URL (SPARQL-text, graph summary). */
+    readConsistencyQuery(opts) {
+        return {
+            consistency: this.resolveConsistency(opts),
+            min_indexed_seq: opts?.minIndexedSeq,
+        };
+    }
     buildUrl(path, query) {
         const params = [];
         const push = (key, value) => params.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
@@ -292,11 +323,14 @@ export class LbbClient {
     }
     // --- writes ---
     /** Commit triplets and optional entity embeddings. Prefer `client.graph("main").facts.create(...)`. */
-    commit(body, opts = {}) {
-        return this.request("POST", "/v1/graph/commit", {
+    async commit(body, opts = {}) {
+        const response = await this.request("POST", "/v1/graph/commit", {
             body,
             idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("facts.create"),
         });
+        // A5: surface the committed sequence as `commitSeq` so the write→floor→read
+        // loop reads naturally: `const { commitSeq } = await client.commit(…)`.
+        return { ...response, commitSeq: response.commit_seq };
     }
     /**
      * Validate-only preflight: run the same ontology/schema validation a real
@@ -318,28 +352,28 @@ export class LbbClient {
      * streamed request without a single oversized commit. Pass `lines` as an array
      * (serialized to NDJSON here) or a pre-built NDJSON string.
      *
-     * Set `index: true` to run one full index build after the last batch, so the
-     * data is served from the persisted runs (not just the ephemeral snapshot
-     * fallback) by the time the call returns — the "bulk load, queryable on return"
-     * path. Prefer this over indexing per batch (which serializes builds and races
-     * the throttle): import the whole dataset, index once. The response's `index`
-     * object reports whether the build ran or was skipped.
+     * A successful import durably enqueues one complete published-generation
+     * build after the final batch. It does not build index families or wait for
+     * visibility; the response's `published_generation` object carries the
+     * durable job and due sequence to observe.
      */
-    import(lines, opts = {}) {
+    async import(lines, opts = {}) {
         const ndjson = typeof lines === "string"
             ? lines
             : lines.map((line) => JSON.stringify(line)).join("\n");
-        return this.request("POST", "/v1/graph/import", {
+        const response = await this.request("POST", "/v1/graph/import", {
             rawBody: ndjson,
             contentType: "application/x-ndjson",
             query: {
                 batch: opts.batch,
                 strict: opts.strict,
                 observed_at: opts.observedAt,
-                index: opts.index,
             },
             idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("import"),
         });
+        // A5: surface the last committed sequence (null for an empty import) so the
+        // write→floor→read loop reads naturally after a bulk load.
+        return { ...response, commitSeq: response.committed_commit_seq ?? null };
     }
     /**
      * Bulk-ingest N-Triples, Turtle, N-Quads, or TriG without client-side conversion. Resource-object
@@ -371,19 +405,6 @@ export class LbbClient {
             idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("import-rdf"),
         });
     }
-    /** Export the snapshot-visible RDF projection as Turtle, N-Triples, TriG, or N-Quads. */
-    exportRdf(opts = {}) {
-        return this.request("GET", "/v1/graph/export/rdf", {
-            query: {
-                format: opts.format === "ntriples" ? "nt" : opts.format,
-                max_triples: opts.maxTriples,
-                as_of_valid_time: opts.asOfValidTime,
-                as_of_commit_seq: opts.asOfCommitSeq,
-                entailment: opts.entailment,
-                reason: opts.reason,
-            },
-        });
-    }
     /**
      * Retract specific edges and/or every edge touching given entities. Appends
      * superseding retract events rather than deleting — history stays visible in an
@@ -601,23 +622,19 @@ export class LbbClient {
             query: { kind: opts.kind, run: opts.run },
         });
     }
-    /**
-     * Champion vs challenger retrieval over one pinned snapshot. Returns
-     * promotion evidence (hit-rate@k, latency, overlap); never promotes.
-     */
-    shadowEval(body) {
-        return this.request("POST", "/v1/models/shadow-eval", { body });
-    }
-    /**
-     * Execution-verified QA probes generated from the graph's current edges —
-     * labels are the executed projections, so they are verified by construction.
-     * Feeds `shadowEval` directly.
-     */
+    /** Execution-verified QA probes generated from the graph's current edges. */
     syntheticEval(opts = {}) {
         return this.request("GET", "/v1/models/synthetic-eval", {
             query: { limit: opts.limit },
         });
     }
+    /**
+     * Compare champion and challenger retrieval over one pinned published
+     * snapshot. The endpoint returns promotion evidence but never promotes.
+     */
+    shadowEval(body) {
+        return this.request("POST", "/v1/models/shadow-eval", { body });
+    }
     /** The doubling retrain policy: is a retrain due for this model kind? */
     modelCadence(opts) {
         return this.request("GET", "/v1/models/cadence", {
@@ -643,18 +660,6 @@ export class LbbClient {
     setTrainingConfig(body) {
         return this.request("POST", "/v1/models/training-config", { body });
     }
-    /**
-     * Verdict on an ask (`accepted` | `rejected` | `corrected` + the right
-     * plan), joined to the ask's trace by `ask_id` — the planner fine-tune's
-     * explicit feedback capture. `accepted: false` in the response means
-     * signal capture is off on this deployment (the contract is identical).
-     */
-    askFeedback(body, opts = {}) {
-        return this.request("POST", "/v1/ask/feedback", {
-            body,
-            idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("ask-feedback"),
-        });
-    }
     ingestSignals(body, opts = {}) {
         return this.request("POST", "/v1/signals", {
             body,
@@ -679,39 +684,25 @@ export class LbbClient {
             ],
         }, opts);
     }
-    /**
-     * The planner fine-tune's training feed: accepted/corrected feedback
-     * joined to its traces (signals ≤ the split pin), topped up with
-     * execution-verified synthetic plans.
-     */
+    /** Planner training examples at or before an optional signal split. */
     plannerDataset(opts = {}) {
         return this.request("GET", "/v1/models/planner-dataset", {
             query: { limit: opts.limit, split_seq: opts.splitSeq },
         });
     }
-    /**
-     * The DPO pass's training feed: preference pairs from corrected verdicts,
-     * paired rejections, and synthetic corrupted-slot pairs.
-     */
+    /** Planner preference pairs at or before an optional signal split. */
     plannerPreferenceDataset(opts = {}) {
         return this.request("GET", "/v1/models/planner-preference-dataset", {
             query: { limit: opts.limit, split_seq: opts.splitSeq },
         });
     }
-    /**
-     * The suggest-ranker trainer's probe feed: `suggestion_adopted` signals
-     * (typed prefix + adopted text) ≤ the split pin, topped up with
-     * execution-verified synthetic vocabulary pairs.
-     */
+    /** Suggest-ranker examples at or before an optional signal split. */
     suggestDataset(opts = {}) {
         return this.request("GET", "/v1/models/suggest-dataset", {
             query: { limit: opts.limit, split_seq: opts.splitSeq },
         });
     }
-    /**
-     * The extractor fine-tune's training feed: EPISODE transcripts joined to
-     * the facts the observe pipeline committed from them.
-     */
+    /** Extractor examples at or before an optional signal split. */
     extractorDataset(opts = {}) {
         return this.request("GET", "/v1/models/extractor-dataset", {
             query: { limit: opts.limit, split_seq: opts.splitSeq },
@@ -729,8 +720,7 @@ export class LbbClient {
     }
     /**
      * Promote a finished `planner_lora` training run: gated on held-out slot
-     * exactness, recorded as a `kind=planner` training run whose adapter `/v1/ask`
-     * then serves.
+     * exactness and recorded as a `kind=planner` training run.
      */
     promotePlanner(opts) {
         return this.request("POST", "/v1/models/promote-planner", {
@@ -739,8 +729,15 @@ export class LbbClient {
     }
     // --- search ---
     /** Full semantic hybrid search from a request body (`POST /v1/graph/search`). */
-    graphSearch(body) {
-        return this.request("POST", "/v1/graph/search", { body });
+    graphSearch(body, opts) {
+        // Consistency for hybrid graph search lives on the nested `search` options.
+        const consistency = this.resolveConsistency(opts);
+        const search = consistency !== undefined || opts?.minIndexedSeq !== undefined
+            ? this.mergeReadConsistency(body.search ?? {}, opts)
+            : body.search;
+        return this.request("POST", "/v1/graph/search", {
+            body: { ...body, search },
+        });
     }
     /** Reciprocal-rank-fusion across sub-queries. */
     multiSearch(body) {
@@ -754,37 +751,18 @@ export class LbbClient {
     suggest(body) {
         return this.request("POST", "/v1/search/suggest", { body });
     }
-    /**
-     * Snap free text to the nearest real vocabulary item. Embedding cosine
-     * on a managed graph, else lexical; never fabricates a term.
-     */
+    /** Snap free text to the nearest term in the pinned published vocabulary. */
     resolveTerm(body) {
         return this.request("POST", "/v1/search/resolve-term", { body });
     }
-    /**
-     * Ground a natural-language question to the graph's real vocabulary, retrieve
-     * against the pinned snapshot, and answer with citations (`/v1/ask`).
-     */
-    ask(body) {
-        return this.request("POST", "/v1/ask", { body });
-    }
-    /**
-     * Name the relation between two entities (`/v1/decode`): the DB narrows the
-     * candidates to the type pair's admissible relations, answers alone
-     * when the pair forces a single relation, and otherwise decodes it with the
-     * graph-native fine-tuned model — the "DB narrows, cheap model decodes" call.
-     */
+    /** Decode a relation from the graph's admissible published vocabulary. */
     decode(body) {
         return this.request("POST", "/v1/decode", { body });
     }
-    /**
-     * Report which completion mechanisms will carry on this graph:
-     * signature sparsity, name semantics, sampled narrowing recall, and a
-     * narrow / narrow+finetune / lexical-first recommendation.
-     */
+    /** Report completion strategy fitness for the pinned published graph. */
     groundability(opts = {}) {
         return this.request("GET", "/v1/graph/groundability", {
-            query: opts.sample != null ? { sample: String(opts.sample) } : undefined,
+            query: opts.sample == null ? undefined : { sample: opts.sample },
         });
     }
     /**
@@ -805,12 +783,16 @@ export class LbbClient {
         return this.request("GET", "/v1/search/feedback/export");
     }
     /** BM25 search. */
-    fullTextSearch(body) {
-        return this.request("POST", "/v1/search/full-text", { body });
+    fullTextSearch(body, opts) {
+        return this.request("POST", "/v1/search/full-text", {
+            body: this.mergeReadConsistency(body, opts),
+        });
     }
     /** ANN/vector search. */
-    embeddingSearch(body) {
-        return this.request("POST", "/v1/search/embedding", { body });
+    embeddingSearch(body, opts) {
+        return this.request("POST", "/v1/search/embedding", {
+            body: this.mergeReadConsistency(body, opts),
+        });
     }
     // --- traversal ---
     /** Bounded k-hop graph traversal. */
@@ -830,7 +812,6 @@ export class LbbClient {
                 name: opts.name,
                 relations: opts.relations?.join(","),
                 as_of: opts.asOf,
-                indexed: opts.indexed,
             },
         });
     }
@@ -870,39 +851,11 @@ export class LbbClient {
             },
         });
     }
-    /**
-     * Paged edge listing. Scope to one node with `id` (or `type`+`name`) and a
-     * `direction` (`out`/`in`/`both`) to walk **every** edge of a high-degree node
-     * — `entityDetail` returns the full set but is awkward to page; this carries
-     * `offset`/`limit` and reports `total_count`. Optional `relation`/`q` filters
-     * and an `asOf`/`asOfCommitSeq` snapshot pin. Each row carries `valid_time`, so
-     * the page is enough to reconstruct a per-edge timeline.
-     */
-    graphEdges(opts = {}) {
-        return this.request("GET", "/v1/graph/edges", {
-            query: {
-                id: opts.id,
-                type: opts.type,
-                name: opts.name,
-                direction: opts.direction,
-                relation: opts.relation,
-                q: opts.q,
-                limit: opts.limit,
-                cursor: opts.cursor,
-                offset: opts.offset,
-                as_of: opts.asOf,
-                as_of_commit_seq: opts.asOfCommitSeq,
-            },
-        });
-    }
     /**
      * Page through every row of a list endpoint, following `next_cursor` until
      * exhausted. Pass a fetcher that takes a cursor and returns a
      * {@link ListResponse}:
-     * ```ts
-     * for await (const e of client.listAll((cursor) =>
-     *   client.entities.list({ cursor, fields: "title" }))) { … }
-     * ```
+     * The caller supplies a bounded collection endpoint and its cursor.
      */
     async *listAll(fetchPage) {
         let cursor;
@@ -932,10 +885,6 @@ export class LbbClient {
     why(body) {
         return this.request("POST", "/v1/query/why", { body });
     }
-    /** SHACL-style shape/pattern query. */
-    shacl(body) {
-        return this.request("POST", "/v1/query/shacl", { body });
-    }
     /**
      * SPARQL-subset SELECT/ASK/aggregate query (FILTER, HAVING, ORDER BY, ASK,
      * COUNT/SUM/AVG/MIN/MAX). GROUP BY is not limited to entity identity:
@@ -946,12 +895,17 @@ export class LbbClient {
      * keys come back per group in `groups[].value_keys[<as>]`, entity keys in
      * `groups[].keys`.
      */
-    sparql(body) {
-        return this.request("POST", "/v1/query/sparql", { body });
+    sparql(body, opts) {
+        return this.request("POST", "/v1/query/sparql", {
+            body: this.mergeReadConsistency(body, opts),
+        });
     }
-    /** SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is SPARQL 1.1 Query Results JSON. */
-    sparqlText(body) {
-        return this.request("POST", "/v1/query/sparql-text", { body });
+    /** SPARQL 1.1 query from text (SELECT/ASK) over the live graph; `results` is SPARQL 1.1 Query Results JSON. The text dialect carries `consistency`/`min_indexed_seq` on the URL. */
+    sparqlText(body, opts) {
+        return this.request("POST", "/v1/query/sparql-text", {
+            body,
+            query: this.readConsistencyQuery(opts),
+        });
     }
     /**
      * Run a SPARQL 1.1 text query and return parsed results — the ergonomic
@@ -960,8 +914,8 @@ export class LbbClient {
      * `rows` is the bindings flattened to `{ variable: lexicalValue }`, `boolean`
      * is the ASK answer (or `null` for a SELECT).
      */
-    async sparqlRows(body) {
-        return parseSparqlResults(await this.sparqlText(body));
+    async sparqlRows(body, opts) {
+        return parseSparqlResults(await this.sparqlText(body, opts));
     }
     /**
      * Basic-graph-pattern query with group-graph-pattern combinators
@@ -973,36 +927,6 @@ export class LbbClient {
     analytics(body) {
         return this.request("POST", "/v1/query/analytics", { body });
     }
-    /**
-     * Run inference rules (SHACL-AF `sh:TripleRule` shape) to a bounded fixpoint
-     * and return the derived edges as a **preview** — derived facts are never
-     * written to the asserted graph. Each rule is a BGP `body`/`where` plus a
-     * `head` triple template instantiated per binding.
-     */
-    infer(body) {
-        return this.request("POST", "/v1/inference/run", { body });
-    }
-    /**
-     * Define (replace) the versioned rule set stored on the scoped graph branch.
-     * The stored set is what SHACL `include_derived` and `infer` use when a
-     * request carries no inline rules. Returns the new `rules_version`.
-     */
-    defineRules(body) {
-        return this.request("POST", "/v1/inference/rules", { body });
-    }
-    /** The rule set stored on the scoped graph branch (version + rules). */
-    graphRules() {
-        return this.request("GET", "/v1/inference/rules");
-    }
-    /**
-     * Derive edges from calibrated retrieval matches (preview): each
-     * candidate scored `P >= threshold` becomes a derived edge `(anchor, relation,
-     * matched)` with a typed `Retrieval` provenance leaf. Pass either explicit
-     * `candidates` or a `query` the server runs as BM25 entity retrieval.
-     */
-    retrievalPremises(body) {
-        return this.request("POST", "/v1/inference/retrieval-premises", { body });
-    }
     // --- ontology ---
     /**
      * The active ontology (entity types and relations) for the scoped graph.
@@ -1019,12 +943,13 @@ export class LbbClient {
      * Audit the current snapshot against the ontology's *implied* constraints —
      * capped `cardinality` derived as `sh:maxCount` — returning a SHACL-shaped
      * report. Whole-snapshot and never blocks a write. Unlike
-     * {@link SchemaNamespace.audit}, this needs no published shape bundle: the
-     * shapes come from the ontology itself. See the `decoration_status` catalog on
-     * {@link ontologyView} for which decorations are enforced.
+     * The report is referenced by the pinned published read root and carries its
+     * own validation watermark and ontology/shapes provenance.
      */
-    ontologyConformance() {
-        return this.request("GET", "/v1/ontology/conformance");
+    ontologyConformance(opts) {
+        return this.request("GET", "/v1/ontology/conformance", {
+            query: { consistency: this.resolveConsistency(opts) },
+        });
     }
     /** Discover ontology concepts, terms, and relations. */
     ontologySearch(body) {
@@ -1051,75 +976,6 @@ export class LbbClient {
     induceOntology(body) {
         return this.request("POST", "/v1/ontology/induce", { body, retry: true });
     }
-    // --- index lifecycle ---
-    /**
-     * Build default ANN + BM25 indexes. With `{ background: true }` the build
-     * runs detached on the server and the call returns immediately — use it for
-     * large corpora whose synchronous build would exceed a fronting gateway's
-     * timeout (a 504), then poll `metadata()` for completion.
-     */
-    indexBuild(opts = {}) {
-        return this.request("POST", "/v1/index/build", {
-            query: { background: opts.background || undefined },
-        });
-    }
-    /**
-     * Build BM25, ANN/vector, and adjacency index families. With
-     * `{ background: true }` the build runs detached on the server and the call
-     * returns immediately — use it for large corpora whose synchronous build would
-     * exceed a fronting gateway's timeout, then poll `metadata()` for completion.
-     */
-    indexRun(opts = {}) {
-        return this.request("POST", "/v1/index/run", {
-            query: { background: opts.background || undefined },
-        });
-    }
-    /** Submit a durable full-index build. Requires a reconnect-safe idempotency key. */
-    indexSubmit(body = {}, opts) {
-        return this.request("POST", "/v1/index/jobs", {
-            body,
-            idempotencyKey: opts.idempotencyKey,
-        });
-    }
-    /** Poll a durable full-index build. */
-    indexJob(jobId) {
-        return this.request("GET", "/v1/index/jobs", { query: { job_id: jobId } });
-    }
-    /** Cancel a durable full-index build. Repeated cancellation returns its current terminal status. */
-    cancelIndexJob(jobId) {
-        return this.request("DELETE", "/v1/index/jobs", {
-            query: { job_id: jobId },
-        });
-    }
-    /** Append a BM25 delta segment for the unindexed WAL tail. */
-    indexDelta() {
-        return this.request("POST", "/v1/index/delta");
-    }
-    /** Preview or delete superseded persisted index runs. */
-    indexGc(opts = {}) {
-        return this.request("POST", "/v1/index/gc", {
-            query: { keep_runs: opts.keepRuns, dry_run: opts.dryRun },
-        });
-    }
-    /** Submit durable, cancellable index garbage collection. */
-    indexGcSubmit(body = {}, opts) {
-        return this.request("POST", "/v1/index/gc-jobs", {
-            body,
-            idempotencyKey: opts.idempotencyKey,
-        });
-    }
-    /** Poll exact planning/deletion progress for durable index garbage collection. */
-    indexGcJob(jobId) {
-        return this.request("GET", "/v1/index/gc-jobs", {
-            query: { job_id: jobId },
-        });
-    }
-    /** Cancel durable index garbage collection. */
-    cancelIndexGcJob(jobId) {
-        return this.request("DELETE", "/v1/index/gc-jobs", {
-            query: { job_id: jobId },
-        });
-    }
     /** Fold the WAL tail into snapshot segments. */
     compact(opts = {}) {
         return this.request("POST", "/v1/graph/compact", {
@@ -1134,13 +990,11 @@ export class LbbClient {
     status() {
         return this.request("GET", "/v1/status");
     }
-    /** Graph footprint, WAL tail, and index coverage. Exact object inventory is opt-in. */
+    /** Graph footprint, WAL tail, and published-index coverage. */
     metadata(opts = {}) {
         return this.request("GET", "/v1/graph/metadata", {
             query: {
-                include_objects: opts.includeObjects,
                 include_indexes: opts.includeIndexes,
-                include_temporal_coverage: opts.includeTemporalCoverage,
             },
         });
     }
@@ -1175,9 +1029,15 @@ export class LbbClient {
             await sleep(opts.pollIntervalMs ?? 250);
         }
     }
-    /** Graph counts and type/relation buckets. */
-    summary() {
-        return this.request("GET", "/v1/graph/summary");
+    /** Graph counts and type/relation buckets. Carries `consistency`/`min_indexed_seq` on the URL. */
+    summary(opts) {
+        return this.request("GET", "/v1/graph/summary", {
+            query: this.readConsistencyQuery(opts),
+        });
+    }
+    /** Pinned published read root and its query/conformance lag against one coherent head. */
+    readSnapshot() {
+        return this.request("GET", "/v1/graph/read-snapshot");
     }
     /** List the graphs (and branches) under the scoped tenant. */
     listGraphs() {

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { LbbClient, LbbError, parseSparqlResults } from "./client.js";
-export type { LbbClientOptions, CallOptions, RequestOptions, EntityListOptions, HybridSearchOptions, LbbRequestEvent, LbbResponseEvent, FetchLike, Schemas, SparqlResults, SparqlResultsJson, SparqlTerm, AskRequest, AskResponse, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, SearchRequest, SearchResponse, SearchResult, Snapshot, } from "./client.js";
+export type { LbbClientOptions, CallOptions, RequestOptions, HybridSearchOptions, LbbRequestEvent, LbbResponseEvent, FetchLike, ReadConsistencyOptions, SearchConsistency, Schemas, SparqlResults, SparqlResultsJson, SparqlTerm, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, SearchRequest, SearchResponse, SearchResult, Snapshot, } from "./client.js";
 export type { components, paths, operations } from "./schema.js";