@littlebigbrain/client 0.8.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
@@ -28,7 +28,6 @@ export class LbbClient {
     defaultConsistency;
     context;
     search;
-    indexes;
     entities;
     schema;
     ontology;
@@ -43,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;
@@ -72,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);
@@ -354,12 +352,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 +368,6 @@ export class LbbClient {
                 batch: opts.batch,
                 strict: opts.strict,
                 observed_at: opts.observedAt,
-                index: opts.index,
             },
             idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("import"),
         });
@@ -410,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
@@ -640,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", {
@@ -682,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,
@@ -718,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 },
@@ -768,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", {
@@ -800,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 },
         });
     }
     /**
@@ -880,7 +812,6 @@ export class LbbClient {
                 name: opts.name,
                 relations: opts.relations?.join(","),
                 as_of: opts.asOf,
-                indexed: opts.indexed,
             },
         });
     }
@@ -920,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;
@@ -982,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:
@@ -1028,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.
@@ -1074,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) {
@@ -1106,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", {
@@ -1189,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,
             },
         });
     }
@@ -1236,6 +1035,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 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";

package/dist/namespaces.d.ts

@@ -1,9 +1,8 @@
 import type { LbbClient } from "./client.js";
 import type { CallOptions } from "./transport.js";
-import { type EntityAttributeFilterOptions, type ImportLine, type ListResponse, type ReadConsistencyOptions, type RdfExportOptions, type RdfImportOptions, type Schemas } from "./types.js";
+import { type EntityAttributeFilterOptions, type ImportLine, type ReadConsistencyOptions, type RdfImportOptions, type Schemas } from "./types.js";
 export interface HybridSearchOptions extends CallOptions {
     topK?: number;
-    source?: string;
     consistency?: string;
     /** A5 read-your-writes floor (`min_indexed_seq`): the committed sequence a
      * write returned; under eventual, an uncovered floor yields a retryable
@@ -14,10 +13,6 @@ export interface HybridSearchOptions extends CallOptions {
     vector?: boolean;
     targets?: string[];
     profile?: string;
-    /** Valid-time cursor (RFC 3339): results reflect facts true at this instant. */
-    asOf?: string;
-    /** Snapshot pin: results reproduce the graph as of this commit sequence. */
-    asOfCommitSeq?: number;
     /** Opt-in impression logging for later relevance feedback. */
     logImpression?: boolean;
 }
@@ -26,7 +21,6 @@ export declare class GraphNamespace {
     readonly facts: FactsNamespace;
     readonly context: ContextNamespace;
     readonly entities: EntityNamespace;
-    readonly indexes: IndexNamespace;
     readonly ontology: OntologyNamespace;
     readonly query: QueryNamespace;
     readonly schema: SchemaNamespace;
@@ -68,8 +62,6 @@ export declare class GraphNamespace {
     }): Promise<Schemas["ManagedEmbeddingPromoteResponse"]>;
     /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
     retract(body: Schemas["GraphRetractRequest"], opts?: CallOptions): Promise<Schemas["GraphRetractResponse"]>;
-    /** Export this graph's current snapshot as Turtle, N-Triples, TriG, or N-Quads. */
-    exportRdf(opts?: RdfExportOptions): Promise<string>;
 }
 export declare class FactsNamespace {
     private readonly client;
@@ -80,7 +72,6 @@ export declare class FactsNamespace {
         batch?: number;
         strict?: boolean;
         observedAt?: string;
-        index?: boolean;
         idempotencyKey?: string;
     }): Promise<Schemas["GraphImportResponse"]>;
     /**
@@ -103,71 +94,18 @@ export declare class SearchNamespace {
     fullText(body: Schemas["FullTextSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["FullTextSearchResponse"]>;
     vector(body: Schemas["EmbeddingSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["EmbeddingSearchResponse"]>;
 }
-export declare class SchemaNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    /** Active graph schema bundle: ontology plus activated SHACL shapes. */
-    view(opts?: {
-        audit?: boolean;
-    } & CallOptions): Promise<Schemas["SchemaBundleView"]>;
-    /** Preview a proposed RDF/SHACL schema bundle and audit current data. */
-    preview(body: Schemas["SchemaPreviewRequest"], opts?: CallOptions): Promise<Schemas["SchemaPreviewResponse"]>;
-    /** Activate a previewed SHACL schema bundle for this graph branch. */
-    publish(body: Schemas["SchemaPublishRequest"], opts?: CallOptions): Promise<Schemas["SchemaPublishResponse"]>;
-    /** Audit current data against the active SHACL schema bundle. */
-    audit(opts?: CallOptions): Promise<Schemas["SchemaAuditReport"]>;
-}
-export declare class IndexNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    run(opts?: {
-        wait?: boolean;
-        background?: boolean;
-        body?: unknown;
-    } & CallOptions): Promise<unknown>;
-    build(opts?: {
-        background?: boolean;
-    } & CallOptions): Promise<unknown>;
-    delta(opts?: CallOptions): Promise<Schemas["IndexDeltaResponse"]>;
-    submit(body: Partial<Schemas["IndexBuildOptions"]> | undefined, opts: CallOptions & {
-        idempotencyKey: string;
-    }): Promise<Schemas["SearchIndexJobStatusResponse"]>;
-    job(jobId: string, opts?: CallOptions): Promise<Schemas["SearchIndexJobStatusResponse"]>;
-    cancel(jobId: string, opts?: CallOptions): Promise<Schemas["SearchIndexJobStatusResponse"]>;
-    gc(opts?: {
-        keepRuns?: number;
-        dryRun?: boolean;
-    } & CallOptions): Promise<Schemas["IndexGcResponse"]>;
-    submitGc(body: Schemas["IndexGcRequest"] | undefined, opts: CallOptions & {
-        idempotencyKey: string;
-    }): Promise<Schemas["IndexGcJobStatusResponse"]>;
-    gcJob(jobId: string, opts?: CallOptions): Promise<Schemas["IndexGcJobStatusResponse"]>;
-    cancelGc(jobId: string, opts?: CallOptions): Promise<Schemas["IndexGcJobStatusResponse"]>;
-}
 export declare class EntityNamespace {
     private readonly client;
     constructor(client: LbbClient);
     /**
      * Return the exact type cardinality and a bounded deterministic sample from
-     * the ranged adjacency index. The server returns `index_busy` rather than
-     * falling back to an exhaustive snapshot scan when the index is unavailable.
+     * the ranged adjacency family pinned by the published generation. A missing
+     * family fails closed rather than falling back to an exhaustive scan.
      */
     sample(opts: {
         type: string;
         limit?: number;
     } & CallOptions): Promise<Schemas["EntityTypeSampleResponse"]>;
-    /**
-     * Browse entities as the unified list envelope. Pass `fields` (names or `*`)
-     * to inline each row's typed attributes as native JSON (under `attributes`) —
-     * "list entities and their titles" in one call instead of a list plus N point
-     * lookups — or `ids`
-     * to fetch a specific set. Page with `cursor` from the previous `next_cursor`.
-     */
-    list(opts?: EntityListOptions): Promise<ListResponse<Schemas["EntityExplorerRow"]>>;
-    /** Yield list envelopes while following `next_cursor` until exhaustion. */
-    pages(opts?: EntityListOptions): AsyncGenerator<ListResponse<Schemas["EntityExplorerRow"]>>;
-    /** Yield entities directly while following the server's stable cursor. */
-    iterate(opts?: EntityListOptions): AsyncGenerator<Schemas["EntityExplorerRow"]>;
     get(opts: {
         id?: string;
         type?: string;
@@ -187,23 +125,10 @@ export declare class EntityNamespace {
      */
     filterByAttributes(opts: EntityAttributeFilterOptions): Promise<Schemas["SparqlSelectResponse"]>;
 }
-export interface EntityListOptions extends CallOptions {
-    type?: string;
-    limit?: number;
-    cursor?: string | number;
-    /** @deprecated Legacy alias for `cursor`. */
-    offset?: number;
-    query?: string;
-    /** Property names to inline per row (or `"*"` / `["*"]` for all). */
-    fields?: string | string[];
-    /** Specific entity ids to fetch in one call (bulk lookup). */
-    ids?: string | string[];
-}
-/** Grounding and answer operations over the graph's real vocabulary. */
+/** Grounding operations over one pinned published vocabulary. */
 export declare class ContextNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    ask(body: Schemas["AskRequest"], opts?: CallOptions): Promise<Schemas["AskResponse"]>;
     suggest(body: Schemas["SearchSuggestRequest"], opts?: CallOptions): Promise<Schemas["SearchSuggestResponse"]>;
     resolve(body: Schemas["ResolveTermRequest"], opts?: CallOptions): Promise<Schemas["ResolveTermResponse"]>;
     decode(body: Schemas["DecodeRequest"], opts?: CallOptions): Promise<Schemas["DecodeResponse"]>;
@@ -211,6 +136,15 @@ export declare class ContextNamespace {
         sample?: number;
     } & CallOptions): Promise<Schemas["GroundabilityReport"]>;
 }
+/** Active ontology/SHACL bundle metadata and atomic publication. */
+export declare class SchemaNamespace {
+    private readonly client;
+    constructor(client: LbbClient);
+    /** Read active metadata without running request-time validation. */
+    view(opts?: CallOptions): Promise<Schemas["SchemaBundleView"]>;
+    /** Atomically publish a bundle; conformance is produced asynchronously. */
+    publish(body: Schemas["SchemaPublishRequest"], opts?: CallOptions): Promise<Schemas["SchemaPublishResponse"]>;
+}
 /** Ontology discovery and lifecycle operations. */
 export declare class OntologyNamespace {
     private readonly client;
@@ -218,14 +152,14 @@ export declare class OntologyNamespace {
     view(options?: {
         counts?: boolean;
     } & CallOptions): Promise<Schemas["OntologyView"]>;
-    conformance(opts?: CallOptions): Promise<Schemas["SchemaAuditReport"]>;
+    conformance(opts?: CallOptions & Pick<ReadConsistencyOptions, "consistency">): Promise<Schemas["SchemaAuditReport"]>;
     search(body: Schemas["OntologySearchRequest"], opts?: CallOptions): Promise<Schemas["OntologySearchResponse"]>;
     resolve(body: Schemas["OntologyResolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyResolveResponse"]>;
     define(body: Schemas["OntologyDefineRequest"], opts?: CallOptions): Promise<Schemas["OntologyDefineResponse"]>;
     evolve(body: Schemas["OntologyEvolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyEvolveResponse"]>;
     induce(body: Schemas["OntologyInduceRequest"], opts?: CallOptions): Promise<Schemas["OntologyInduceResponse"]>;
 }
-/** Structured, SPARQL-text, reasoning, and analytical query operations. */
+/** Structured, SPARQL-text, and analytical query operations. */
 export declare class QueryNamespace {
     private readonly client;
     constructor(client: LbbClient);
@@ -233,7 +167,4 @@ export declare class QueryNamespace {
     sparql(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<import("./types.js").SparqlResults>;
     sparqlRaw(body: Schemas["SparqlTextRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["SparqlTextResponse"]>;
     analytics(body: Schemas["AnalyticQueryRequest"], opts?: CallOptions): Promise<Schemas["AnalyticQueryResponse"]>;
-    shacl(body: Schemas["ShaclQueryRequest"], opts?: CallOptions): Promise<Schemas["ShaclQueryResponse"]>;
-    infer(body: Schemas["InferenceRunRequest"], opts?: CallOptions): Promise<Schemas["InferenceRunResponse"]>;
-    premises(body: Schemas["RetrievalPremiseRequest"], opts?: CallOptions): Promise<Schemas["RetrievalPremiseResponse"]>;
 }