@littlebigbrain/client 0.8.0 → 0.9.0

package/dist/client.js

@@ -1,9 +1,74 @@
 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 { LbbCapabilityError } from "./transport.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 { LbbCapabilityError, LbbError } from "./transport.js";
+export { ContextNamespace, EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
+function durableImportBytes(line) {
+    if (line instanceof Uint8Array)
+        return line;
+    const encoded = typeof line === "string" ? line : JSON.stringify(line);
+    return new TextEncoder().encode(encoded.endsWith("\n") ? encoded : `${encoded}\n`);
+}
+function durableImportIterator(source) {
+    if (typeof source === "string") {
+        return (async function* () {
+            yield source;
+        })();
+    }
+    if (Symbol.asyncIterator in Object(source)) {
+        return source[Symbol.asyncIterator]();
+    }
+    const iterator = source[Symbol.iterator]();
+    return {
+        next: async () => iterator.next(),
+        return: async () => {
+            iterator.return?.();
+            return { done: true, value: undefined };
+        },
+    };
+}
+function durableImportBody(source) {
+    const iterator = durableImportIterator(source);
+    const Stream = globalThis.ReadableStream;
+    if (Stream) {
+        return new Stream({
+            async pull(controller) {
+                try {
+                    const item = await iterator.next();
+                    if (item.done) {
+                        controller.close();
+                    }
+                    else {
+                        controller.enqueue(durableImportBytes(item.value));
+                    }
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+            async cancel() {
+                await iterator.return?.();
+            },
+        });
+    }
+    return {
+        async *[Symbol.asyncIterator]() {
+            try {
+                for (;;) {
+                    const item = await iterator.next();
+                    if (item.done)
+                        return;
+                    yield durableImportBytes(item.value);
+                }
+            }
+            finally {
+                await iterator.return?.();
+            }
+        },
+    };
+}
 /**
  * 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,11 +89,11 @@ export class LbbClient {
     onRequest;
     onResponse;
     onRetry;
+    capabilities;
     /** A5 default read consistency applied when a read omits its own value. */
     defaultConsistency;
     context;
     search;
-    indexes;
     entities;
     schema;
     ontology;
@@ -43,7 +108,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;
@@ -72,7 +137,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);
@@ -174,6 +238,7 @@ export class LbbClient {
             method,
             headers,
             body,
+            ...(opts.duplex ? { duplex: opts.duplex } : {}),
         };
         const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
         const maxRetries = opts.maxRetries ?? this.maxRetries;
@@ -209,10 +274,16 @@ export class LbbClient {
                     maxAttempts: maxRetries + 1,
                     idempotencyKey: opts.idempotencyKey,
                 });
-                response = await this.fetchImpl(url, {
+                const requestInit = {
                     ...init,
                     signal: controller?.signal ?? opts.signal,
-                });
+                };
+                // Keep FetchLike's long-standing string-body test-double contract while
+                // allowing this one endpoint to pass a native streaming body to fetch.
+                // Native browser/Node fetch implementations accept the extended shape;
+                // custom transports that need durable imports can inspect it at runtime.
+                const streamingFetch = this.fetchImpl;
+                response = await streamingFetch(url, requestInit);
                 text = await response.text();
             }
             catch (error) {
@@ -323,6 +394,12 @@ export class LbbClient {
     idempotencyKey(prefix = "request") {
         return this.mutationKey(prefix);
     }
+    async requireCapability(capability) {
+        this.capabilities ??= this.request("GET", "/version").then((version) => new Set(version.capabilities));
+        if (!(await this.capabilities).has(capability)) {
+            throw new LbbCapabilityError(capability);
+        }
+    }
     // --- writes ---
     /** Commit triplets and optional entity embeddings. Prefer `client.graph("main").facts.create(...)`. */
     async commit(body, opts = {}) {
@@ -354,12 +431,10 @@ 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.
      */
     async import(lines, opts = {}) {
         const ndjson = typeof lines === "string"
@@ -372,7 +447,6 @@ export class LbbClient {
                 batch: opts.batch,
                 strict: opts.strict,
                 observed_at: opts.observedAt,
-                index: opts.index,
             },
             idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("import"),
         });
@@ -380,6 +454,72 @@ export class LbbClient {
         // write→floor→read loop reads naturally after a bulk load.
         return { ...response, commitSeq: response.committed_commit_seq ?? null };
     }
+    /**
+     * Stream NDJSON into immutable storage and enqueue a durable import job.
+     *
+     * The idempotency key is mandatory and binds the key to the uploaded content.
+     * Streaming uploads are attempted once: a one-shot async iterator cannot be
+     * replayed safely by an automatic HTTP retry. Call this method again with a
+     * fresh iterable and the same key to perform an explicit idempotent replay.
+     */
+    async submitImport(lines, opts) {
+        if (!opts?.idempotencyKey?.trim()) {
+            throw new TypeError("submitImport requires a non-empty idempotencyKey");
+        }
+        await this.requireCapability("durable_import_jobs_v1");
+        return this.request("POST", "/v1/graph/import-jobs", {
+            rawBody: durableImportBody(lines),
+            contentType: "application/x-ndjson",
+            duplex: "half",
+            query: {
+                batch: opts.batch,
+                strict: opts.strict,
+                observed_at: opts.observedAt,
+            },
+            idempotencyKey: opts.idempotencyKey,
+            maxRetries: 0,
+            retry: false,
+            signal: opts.signal,
+        });
+    }
+    async getImportJob(jobId) {
+        await this.requireCapability("durable_import_jobs_v1");
+        return this.request("GET", "/v1/graph/import-jobs", {
+            query: { job_id: jobId },
+        });
+    }
+    async cancelImportJob(jobId) {
+        await this.requireCapability("durable_import_jobs_v1");
+        return this.request("DELETE", "/v1/graph/import-jobs", {
+            query: { job_id: jobId },
+        });
+    }
+    async waitForImportJob(jobId, opts = {}) {
+        const pollIntervalMs = opts.pollIntervalMs ?? 1_000;
+        const timeoutMs = opts.timeoutMs ?? 0;
+        if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 0) {
+            throw new RangeError("pollIntervalMs must be a non-negative number");
+        }
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new RangeError("timeoutMs must be a non-negative number");
+        }
+        const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : undefined;
+        for (;;) {
+            if (opts.signal?.aborted) {
+                throw opts.signal.reason ?? new Error("request aborted");
+            }
+            const status = await this.getImportJob(jobId);
+            if (status.state === "succeeded" ||
+                status.state === "failed" ||
+                status.state === "cancelled") {
+                return status;
+            }
+            if (deadline !== undefined && Date.now() >= deadline) {
+                throw new Error(`timed out waiting for durable import job ${jobId}`);
+            }
+            await sleep(pollIntervalMs);
+        }
+    }
     /**
      * Bulk-ingest N-Triples, Turtle, N-Quads, or TriG without client-side conversion. Resource-object
      * triples become keyed Resource edges; literal-object triples become text
@@ -410,19 +550,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
@@ -640,23 +767,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", {
@@ -682,18 +805,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,
@@ -718,39 +829,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 },
@@ -768,8 +865,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", {
@@ -800,37 +896,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 },
         });
     }
     /**
@@ -880,7 +957,6 @@ export class LbbClient {
                 name: opts.name,
                 relations: opts.relations?.join(","),
                 as_of: opts.asOf,
-                indexed: opts.indexed,
             },
         });
     }
@@ -920,39 +996,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;
@@ -982,10 +1030,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:
@@ -1028,36 +1072,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.
@@ -1074,12 +1088,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) {
@@ -1106,75 +1121,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", {
@@ -1189,13 +1135,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,
             },
         });
     }
@@ -1236,6 +1180,10 @@ export class LbbClient {
             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() {
         return this.request("GET", "/v1/graphs");

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, ReadConsistencyOptions, SearchConsistency, Schemas, SparqlResults, SparqlResultsJson, SparqlTerm, AskRequest, AskResponse, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, SearchRequest, SearchResponse, SearchResult, Snapshot, } from "./client.js";
+export { LbbCapabilityError, LbbClient, LbbError, parseSparqlResults, } from "./client.js";
+export type { DurableImportLine, DurableImportSource, 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";

package/dist/index.js

@@ -1 +1 @@
-export { LbbClient, LbbError, parseSparqlResults } from "./client.js";
+export { LbbCapabilityError, LbbClient, LbbError, parseSparqlResults, } from "./client.js";