@littlebigbrain/client 0.9.1 → 0.11.0

package/README.md

@@ -36,11 +36,10 @@ await graph.facts.create(
 const published = await lbb.readSnapshot();
 console.log(published.snapshot.served_at_seq, published.query_lag_commits);
 
-// 3. Hybrid search over the snapshot.
-const results = await graph.search.hybrid(
-  "How long are customer records retained?",
-  { topK: 10, consistency: "eventual" },
-);
+// 3. Query the snapshot with SPARQL.
+const rows = await lbb.sparqlRows({
+  query: "SELECT ?s ?o WHERE { ?s <policy:retention> ?o } LIMIT 10",
+});
 ```
 
 For hosted use, `baseUrl` is required and must be the exact `endpoint_url`
@@ -49,23 +48,6 @@ parameters; they are not encoded in the hostname.
 
 ## Examples
 
-**Search with filters.** Pass the request body to filter before ranking — here, only facts an ACL principal may see:
-
-```ts
-const results = await graph.search.hybrid({
-  query: "incident response runbook",
-  targets: ["entities"],
-  search: {
-    filters: {
-      op: "overlaps",
-      field: "acl",
-      values: ["user:rino@example.com", "group:engineering"],
-    },
-  },
-  top_k: 20,
-});
-```
-
 **Bulk import.** Load an array of records (or an NDJSON string) in one call:
 
 ```ts
@@ -93,10 +75,13 @@ commit is durable and final publication was enqueued; it does not mean indexes
 have already reached `committed_commit_seq`. An empty iterable is rejected
 locally before an import POST is sent.
 
-**Time-travel read.** Pin any search to a past instant — results reflect the graph as it was then:
+**Time-travel read.** Pin a SPARQL read to a past instant — results reflect the graph as it was then:
 
 ```ts
-const asOf = await graph.search.hybrid("retention policy", { asOf: "2026-01-01T00:00:00Z" });
+const asOf = await lbb.sparqlRows({
+  query: "SELECT ?s ?o WHERE { ?s <policy:retention> ?o }",
+  as_of_valid_time: "2026-01-01T00:00:00Z",
+});
 ```
 
 **SPARQL.** `sparqlRows` runs a SPARQL 1.1 SELECT/ASK and returns parsed rows:
@@ -113,9 +98,9 @@ Methods return parsed JSON and throw `LbbError` (with `status`, `code`, `message
 
 ## More
 
-The `graph(...)` scope exposes `facts`, `search`, `entities`, `ontology`,
-`query`, `schema`, and `context` namespaces. `context` includes vocabulary
-suggestion, term resolution, relation decoding, and groundability inspection; `schema`
+The `graph(...)` scope exposes `facts`, `entities`, `ontology`, `query`,
+`search` (feedback surfaces), and `schema` namespaces. `query` runs SPARQL,
+the one query language on the API; `schema`
 reads or atomically publishes the active ontology/shapes bundle. Writes enqueue
 published-generation maintenance automatically. Every generated shape is
 available as `Schemas["TypeName"]`.

package/dist/client.d.ts

@@ -1,12 +1,11 @@
 import type { DurableImportSource, ImportLine, LbbClientOptions, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportOptions, Schemas, SearchConsistency, SparqlResults } from "./types.js";
 import { type CallOptions, type RequestOptions } from "./transport.js";
-import { ContextNamespace, EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace } from "./namespaces.js";
+import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace } from "./namespaces.js";
 export { parseSparqlResults } from "./types.js";
-export type { AttributeFilter, AttributeFilterOp, AttributeFilterValue, EntityAttributeFilterOptions, EntityPropertiesLine, DurableImportLine, DurableImportSource, FetchLike, FlatProperties, ImportLine, LbbClientOptions, LbbRequestEvent, LbbResponseEvent, LbbRetryEvent, LbbErrorPayload, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportOptions, Schemas, SearchConsistency, SparqlResults, SparqlResultsJson, SparqlTerm, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, SearchRequest, SearchResponse, SearchResult, Snapshot, } from "./types.js";
+export type { AttributeFilter, AttributeFilterOp, AttributeFilterValue, EntityAttributeFilterOptions, EntityPropertiesLine, DurableImportLine, DurableImportSource, FetchLike, FlatProperties, ImportLine, LbbClientOptions, LbbRequestEvent, LbbResponseEvent, LbbRetryEvent, LbbErrorPayload, ListResponse, RawLbbResponse, ReadConsistencyOptions, RdfImportOptions, Schemas, SearchConsistency, SparqlResults, SparqlResultsJson, SparqlTerm, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, Snapshot, } from "./types.js";
 export { LbbCapabilityError, LbbError } from "./transport.js";
 export type { CallOptions, Query, QueryValue, RequestOptions, } from "./transport.js";
-export type { HybridSearchOptions } from "./namespaces.js";
-export { ContextNamespace, EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
+export { EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
 export interface IndexLineageObservation {
     metadata: Schemas["GraphMetadataResponse"];
     lineage: Schemas["IndexLineage"];
@@ -39,7 +38,6 @@ export declare class LbbClient {
     private capabilities?;
     /** A5 default read consistency applied when a read omits its own value. */
     readonly defaultConsistency?: SearchConsistency;
-    readonly context: ContextNamespace;
     readonly search: SearchNamespace;
     readonly entities: EntityNamespace;
     readonly schema: SchemaNamespace;
@@ -213,47 +211,6 @@ export declare class LbbClient {
     deleteBranch(opts: {
         confirm: string;
     }): Promise<Schemas["GraphBranchDeleteResponse"]>;
-    embeddingConfig(): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    /** List the embedding models available on this deployment. */
-    embeddingModels(): Promise<Schemas["ManagedEmbeddingModelsResponse"]>;
-    /**
-     * Choose the model used automatically for writes and vector queries.
-     * Provider credentials and native dimension discovery stay server-side.
-     */
-    setEmbeddingModel(modelId: string, opts?: {
-        autoEmbedQuery?: boolean;
-    }): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    /** Advanced configuration escape hatch. Prefer `setEmbeddingModel`. */
-    setEmbeddingConfig(body: Schemas["ManagedEmbeddingConfigRequest"]): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    submitEmbeddingBackfill(opts?: {
-        batchSize?: number;
-        limit?: number;
-        full?: boolean;
-        idempotencyKey?: string;
-    }): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    embeddingBackfillJob(jobId: string): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    cancelEmbeddingBackfill(jobId: string): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    backfillEmbeddings(opts?: {
-        batchSize?: number;
-        limit?: number;
-        full?: boolean;
-        idempotencyKey?: string;
-        timeoutMs?: number;
-        pollIntervalMs?: number;
-    }): Promise<Schemas["ManagedEmbeddingBackfillResponse"]>;
-    promoteEmbedding(opts: {
-        runId: string;
-        allowRegression?: boolean;
-    }): Promise<Schemas["ManagedEmbeddingPromoteResponse"]>;
-    /**
-     * The graph's grounding vocabulary as byte-sorted, deduped string sections —
-     * the canonical input for a decoder-side automaton (FST/trie) and the
-     * vocabulary half of an export bundle.
-     */
-    vocabExport(opts?: {
-        sections?: string[];
-        limit?: number;
-    }): Promise<Schemas["VocabExportResponse"]>;
     /**
      * Captured signals by flush-seq range, oldest first — the model-training
      * feed. The `seq` on each signal is the temporal-split coordinate (train ≤ T,
@@ -366,29 +323,11 @@ export declare class LbbClient {
         runId: string;
         allowRegression?: boolean;
     }): Promise<unknown>;
-    /** Full semantic hybrid search from a request body (`POST /v1/graph/search`). */
-    graphSearch(body: Schemas["SemanticGraphSearchRequest"], opts?: ReadConsistencyOptions): Promise<Schemas["SemanticGraphSearchResponse"]>;
-    /** Reciprocal-rank-fusion across sub-queries. */
-    multiSearch(body: Schemas["HybridMultiSearchRequest"]): Promise<Schemas["HybridMultiSearchResponse"]>;
-    /**
-     * Grounded prefix completion from the index vocabulary + ontology. Optionally
-     * narrow relation completions by a type-signature `context` — a type
-     * pair that admits a single relation flags `signature_forced`.
-     */
-    suggest(body: Schemas["SearchSuggestRequest"]): Promise<Schemas["SearchSuggestResponse"]>;
-    /** Snap free text to the nearest term in the pinned published vocabulary. */
-    resolveTerm(body: Schemas["ResolveTermRequest"]): Promise<Schemas["ResolveTermResponse"]>;
-    /** Decode a relation from the graph's admissible published vocabulary. */
-    decode(body: Schemas["DecodeRequest"]): Promise<Schemas["DecodeResponse"]>;
-    /** Report completion strategy fitness for the pinned published graph. */
-    groundability(opts?: {
-        sample?: number;
-    }): Promise<Schemas["GroundabilityReport"]>;
     /**
-     * Append relevance labels for a set of search results — how little big brain
+     * Append relevance labels for a set of ranked results — how little big brain
      * gathers customer-specific qrels. Grade results (3 ideal/good, 1 partial,
-     * 0 bad), referencing the search response's `search_id` so labels tie back to
-     * that ranking. Stored apart from customer facts and exported via
+     * 0 bad), referencing the ranking's `search_id` so labels tie back to it.
+     * Stored apart from customer facts and exported via
      * {@link searchFeedbackExport} as training/eval data for embedding fine-tuning.
      */
     searchFeedback(body: Schemas["SearchFeedbackRequest"], opts?: {
@@ -396,23 +335,22 @@ export declare class LbbClient {
     }): Promise<Schemas["SearchFeedbackResponse"]>;
     /** Export the stored relevance labels as qrels-style rows for training. */
     searchFeedbackExport(): Promise<Schemas["SearchFeedbackExportResponse"]>;
-    /** BM25 search. */
-    fullTextSearch(body: Schemas["FullTextSearchRequest"], opts?: ReadConsistencyOptions): Promise<Schemas["FullTextSearchResponse"]>;
-    /** ANN/vector search. */
-    embeddingSearch(body: Schemas["EmbeddingSearchRequest"], opts?: ReadConsistencyOptions): Promise<Schemas["EmbeddingSearchResponse"]>;
-    /** Bounded k-hop graph traversal. */
-    traverse(body: Schemas["TraverseRequest"]): Promise<Schemas["TraverseResponse"]>;
-    /** Resolve a query to seed entities, then return bounded paths. */
-    semanticTraverse(body: Schemas["SemanticTraverseRequest"]): Promise<Schemas["SemanticTraverseResponse"]>;
-    /** Ranked incoming/outgoing neighborhood for a graph entity. */
+    /**
+     * Ranked incoming/outgoing neighborhood for a graph entity.
+     *
+     * `edges` caps the edges returned per direction (default 1000, maximum
+     * 10000). When a cap cuts a direction the response carries a `truncation`
+     * block; an uncut response omits it entirely.
+     */
     entityNeighborhood(opts: {
         id?: string;
         type?: string;
         name?: string;
         relations?: string[];
         asOf?: string;
+        edges?: number;
     }): Promise<Schemas["EntityNeighborhoodResponse"]>;
-    /** Exact type cardinality plus a bounded deterministic sample from ranged adjacency. */
+    /** Exact type cardinality plus a bounded deterministic sample from Base. */
     entityTypeSample(opts: {
         type: string;
         limit?: number;
@@ -473,14 +411,6 @@ export declare class LbbClient {
      * is the ASK answer (or `null` for a SELECT).
      */
     sparqlRows(body: Schemas["SparqlTextRequest"], opts?: ReadConsistencyOptions): Promise<SparqlResults>;
-    /**
-     * Basic-graph-pattern query with group-graph-pattern combinators
-     * (UNION / OPTIONAL / MINUS / EXISTS / NOT EXISTS) folded over the base
-     * patterns. The complement to {@link sparql}: this route carries the
-     * combinators (but not FILTER/aggregation), so use it when a query needs an
-     * optional/union/negated leg rather than a grouped aggregate.
-     */
-    analytics(body: Schemas["AnalyticQueryRequest"]): Promise<Schemas["AnalyticQueryResponse"]>;
     /**
      * The active ontology (entity types and relations) for the scoped graph.
      * Pass `{ counts: true }` to include a per-relation current-edge count

package/dist/client.js

@@ -1,10 +1,10 @@
 import { parseSparqlResults } from "./types.js";
 import { bodyMarksTerminal, errorCodeFromBody, fullJitterBackoffMs, parseLbbError, parseResponseJson, retryAllowed, retryableStatus, retryDelayMs, sleep, } from "./transport.js";
 import { LbbCapabilityError } from "./transport.js";
-import { ContextNamespace, EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
+import { EntityNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
 export { parseSparqlResults } from "./types.js";
 export { LbbCapabilityError, LbbError } from "./transport.js";
-export { ContextNamespace, EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
+export { EntityNamespace, FactsNamespace, GraphNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
 function durableImportBytes(line) {
     if (line instanceof Uint8Array)
         return line;
@@ -105,7 +105,6 @@ export class LbbClient {
     capabilities;
     /** A5 default read consistency applied when a read omits its own value. */
     defaultConsistency;
-    context;
     search;
     entities;
     schema;
@@ -148,7 +147,6 @@ export class LbbClient {
             throw new Error("no fetch implementation available; pass options.fetch");
         }
         this.fetchImpl = chosen;
-        this.context = new ContextNamespace(this);
         this.search = new SearchNamespace(this);
         this.entities = new EntityNamespace(this);
         this.schema = new SchemaNamespace(this);
@@ -560,6 +558,7 @@ export class LbbClient {
                 blank_node_scope: opts.blankNodeScope,
                 resource_type: opts.resourceType,
                 edge_idempotency: opts.edgeIdempotency,
+                build: opts.build,
             },
             idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("import-rdf"),
         });
@@ -667,78 +666,7 @@ export class LbbClient {
             query: { confirm: opts.confirm },
         });
     }
-    embeddingConfig() {
-        return this.request("GET", "/v1/graph/embedding");
-    }
-    /** List the embedding models available on this deployment. */
-    embeddingModels() {
-        return this.request("GET", "/v1/graph/embedding/models");
-    }
-    /**
-     * Choose the model used automatically for writes and vector queries.
-     * Provider credentials and native dimension discovery stay server-side.
-     */
-    setEmbeddingModel(modelId, opts = {}) {
-        return this.setEmbeddingConfig({
-            model_id: modelId,
-            service: "open_router",
-            auto_embed_query: opts.autoEmbedQuery ?? true,
-        });
-    }
-    /** Advanced configuration escape hatch. Prefer `setEmbeddingModel`. */
-    setEmbeddingConfig(body) {
-        return this.request("POST", "/v1/graph/embedding", { body });
-    }
-    submitEmbeddingBackfill(opts = {}) {
-        return this.request("POST", "/v1/graph/embedding/backfill-jobs", {
-            body: {
-                batch_size: opts.batchSize,
-                limit: opts.limit,
-                full: opts.full ?? false,
-            },
-            idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("embedding-backfill"),
-        });
-    }
-    embeddingBackfillJob(jobId) {
-        return this.request("GET", "/v1/graph/embedding/backfill-jobs", {
-            query: { job_id: jobId },
-        });
-    }
-    cancelEmbeddingBackfill(jobId) {
-        return this.request("DELETE", "/v1/graph/embedding/backfill-jobs", {
-            query: { job_id: jobId },
-        });
-    }
-    async backfillEmbeddings(opts = {}) {
-        let status = await this.submitEmbeddingBackfill(opts);
-        const deadline = Date.now() + (opts.timeoutMs ?? 30 * 60_000);
-        while (status.status === "pending" || status.status === "running") {
-            if (Date.now() >= deadline)
-                throw new Error(`embedding backfill ${status.job_id} did not finish before timeout`);
-            await sleep(opts.pollIntervalMs ?? 2_000);
-            status = await this.embeddingBackfillJob(status.job_id);
-        }
-        if (status.status !== "succeeded" || status.result == null)
-            throw new Error(status.terminal_error ??
-                `embedding backfill ${status.job_id} ended ${status.status}`);
-        return status.result;
-    }
-    promoteEmbedding(opts) {
-        return this.request("POST", "/v1/graph/embedding/promote", {
-            query: { run_id: opts.runId, allow_regression: opts.allowRegression },
-        });
-    }
     // --- models as runs (training-run registry + eval machinery) ---
-    /**
-     * The graph's grounding vocabulary as byte-sorted, deduped string sections —
-     * the canonical input for a decoder-side automaton (FST/trie) and the
-     * vocabulary half of an export bundle.
-     */
-    vocabExport(opts = {}) {
-        return this.request("GET", "/v1/search/vocab", {
-            query: { sections: opts.sections?.join(","), limit: opts.limit },
-        });
-    }
     /**
      * Captured signals by flush-seq range, oldest first — the model-training
      * feed. The `seq` on each signal is the temporal-split coordinate (train ≤ T,
@@ -886,49 +814,12 @@ export class LbbClient {
             query: { run_id: opts.runId, allow_regression: opts.allowRegression },
         });
     }
-    // --- search ---
-    /** Full semantic hybrid search from a request body (`POST /v1/graph/search`). */
-    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) {
-        return this.request("POST", "/v1/search/multi", { body });
-    }
+    // --- relevance feedback ---
     /**
-     * Grounded prefix completion from the index vocabulary + ontology. Optionally
-     * narrow relation completions by a type-signature `context` — a type
-     * pair that admits a single relation flags `signature_forced`.
-     */
-    suggest(body) {
-        return this.request("POST", "/v1/search/suggest", { body });
-    }
-    /** Snap free text to the nearest term in the pinned published vocabulary. */
-    resolveTerm(body) {
-        return this.request("POST", "/v1/search/resolve-term", { body });
-    }
-    /** Decode a relation from the graph's admissible published vocabulary. */
-    decode(body) {
-        return this.request("POST", "/v1/decode", { body });
-    }
-    /** Report completion strategy fitness for the pinned published graph. */
-    groundability(opts = {}) {
-        return this.request("GET", "/v1/graph/groundability", {
-            query: opts.sample == null ? undefined : { sample: opts.sample },
-        });
-    }
-    /**
-     * Append relevance labels for a set of search results — how little big brain
+     * Append relevance labels for a set of ranked results — how little big brain
      * gathers customer-specific qrels. Grade results (3 ideal/good, 1 partial,
-     * 0 bad), referencing the search response's `search_id` so labels tie back to
-     * that ranking. Stored apart from customer facts and exported via
+     * 0 bad), referencing the ranking's `search_id` so labels tie back to it.
+     * Stored apart from customer facts and exported via
      * {@link searchFeedbackExport} as training/eval data for embedding fine-tuning.
      */
     searchFeedback(body, opts = {}) {
@@ -941,28 +832,13 @@ export class LbbClient {
     searchFeedbackExport() {
         return this.request("GET", "/v1/search/feedback/export");
     }
-    /** BM25 search. */
-    fullTextSearch(body, opts) {
-        return this.request("POST", "/v1/search/full-text", {
-            body: this.mergeReadConsistency(body, opts),
-        });
-    }
-    /** ANN/vector search. */
-    embeddingSearch(body, opts) {
-        return this.request("POST", "/v1/search/embedding", {
-            body: this.mergeReadConsistency(body, opts),
-        });
-    }
-    // --- traversal ---
-    /** Bounded k-hop graph traversal. */
-    traverse(body) {
-        return this.request("POST", "/v1/graph/traverse", { body });
-    }
-    /** Resolve a query to seed entities, then return bounded paths. */
-    semanticTraverse(body) {
-        return this.request("POST", "/v1/graph/semantic-traverse", { body });
-    }
-    /** Ranked incoming/outgoing neighborhood for a graph entity. */
+    /**
+     * Ranked incoming/outgoing neighborhood for a graph entity.
+     *
+     * `edges` caps the edges returned per direction (default 1000, maximum
+     * 10000). When a cap cuts a direction the response carries a `truncation`
+     * block; an uncut response omits it entirely.
+     */
     entityNeighborhood(opts) {
         return this.request("GET", "/v1/graph/entity/neighborhood", {
             query: {
@@ -971,10 +847,11 @@ export class LbbClient {
                 name: opts.name,
                 relations: opts.relations?.join(","),
                 as_of: opts.asOf,
+                edges: opts.edges,
             },
         });
     }
-    /** Exact type cardinality plus a bounded deterministic sample from ranged adjacency. */
+    /** Exact type cardinality plus a bounded deterministic sample from Base. */
     entityTypeSample(opts) {
         const { type, limit, ...request } = opts;
         return this.request("GET", "/v1/graph/entities/sample", {
@@ -1076,16 +953,6 @@ export class LbbClient {
     async sparqlRows(body, opts) {
         return parseSparqlResults(await this.sparqlText(body, opts));
     }
-    /**
-     * Basic-graph-pattern query with group-graph-pattern combinators
-     * (UNION / OPTIONAL / MINUS / EXISTS / NOT EXISTS) folded over the base
-     * patterns. The complement to {@link sparql}: this route carries the
-     * combinators (but not FILTER/aggregation), so use it when a query needs an
-     * optional/union/negated leg rather than a grouped aggregate.
-     */
-    analytics(body) {
-        return this.request("POST", "/v1/query/analytics", { body });
-    }
     // --- ontology ---
     /**
      * The active ontology (entity types and relations) for the scoped graph.
@@ -1167,9 +1034,7 @@ export class LbbClient {
                 lineage.bm25_indexed_commit_seq != null &&
                 lineage.bm25_indexed_commit_seq >= targetSeq &&
                 lineage.ann_indexed_commit_seq != null &&
-                lineage.ann_indexed_commit_seq >= targetSeq &&
-                lineage.adjacency_indexed_commit_seq != null &&
-                lineage.adjacency_indexed_commit_seq >= targetSeq) {
+                lineage.ann_indexed_commit_seq >= targetSeq) {
                 return {
                     metadata: last.data,
                     lineage,

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 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 { DurableImportLine, DurableImportSource, LbbClientOptions, CallOptions, RequestOptions, LbbRequestEvent, LbbResponseEvent, FetchLike, ReadConsistencyOptions, SearchConsistency, Schemas, SparqlResults, SparqlResultsJson, SparqlTerm, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, Snapshot, } from "./client.js";
 export type { components, paths, operations } from "./schema.js";

package/dist/namespaces.d.ts

@@ -1,25 +1,9 @@
 import type { LbbClient } from "./client.js";
 import type { CallOptions } from "./transport.js";
 import { type EntityAttributeFilterOptions, type ImportLine, type ReadConsistencyOptions, type RdfImportOptions, type Schemas } from "./types.js";
-export interface HybridSearchOptions extends CallOptions {
-    topK?: number;
-    consistency?: string;
-    /** A5 read-your-writes floor (`min_indexed_seq`): the committed sequence a
-     * write returned; under eventual, an uncovered floor yields a retryable
-     * `read_your_writes_pending` 429. */
-    minIndexedSeq?: number;
-    lexical?: boolean;
-    bm25?: boolean;
-    vector?: boolean;
-    targets?: string[];
-    profile?: string;
-    /** Opt-in impression logging for later relevance feedback. */
-    logImpression?: boolean;
-}
 export declare class GraphNamespace {
     private readonly client;
     readonly facts: FactsNamespace;
-    readonly context: ContextNamespace;
     readonly entities: EntityNamespace;
     readonly ontology: OntologyNamespace;
     readonly query: QueryNamespace;
@@ -34,32 +18,6 @@ export declare class GraphNamespace {
     deleteBranch(opts: {
         confirm: string;
     } & CallOptions): Promise<Schemas["GraphBranchDeleteResponse"]>;
-    embeddingConfig(opts?: CallOptions): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    /** List the embedding models available on this deployment. */
-    embeddingModels(opts?: CallOptions): Promise<Schemas["ManagedEmbeddingModelsResponse"]>;
-    /** Choose the model used automatically for writes and vector queries. */
-    setEmbeddingModel(modelId: string, options?: CallOptions & {
-        autoEmbedQuery?: boolean;
-    }): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    /** Advanced configuration escape hatch. Prefer `setEmbeddingModel`. */
-    setEmbeddingConfig(body: Schemas["ManagedEmbeddingConfigRequest"], opts?: CallOptions): Promise<Schemas["ManagedEmbeddingConfigResponse"]>;
-    backfillEmbeddings(options?: CallOptions & {
-        batchSize?: number;
-        limit?: number;
-        full?: boolean;
-        pollIntervalMs?: number;
-    }): Promise<Schemas["ManagedEmbeddingBackfillResponse"]>;
-    submitEmbeddingBackfill(options?: CallOptions & {
-        batchSize?: number;
-        limit?: number;
-        full?: boolean;
-    }): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    embeddingBackfillJob(jobId: string): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    cancelEmbeddingBackfill(jobId: string): Promise<Schemas["ManagedEmbeddingBackfillJobStatusResponse"]>;
-    promoteEmbedding(options: CallOptions & {
-        runId: string;
-        allowRegression?: boolean;
-    }): Promise<Schemas["ManagedEmbeddingPromoteResponse"]>;
     /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
     retract(body: Schemas["GraphRetractRequest"], opts?: CallOptions): Promise<Schemas["GraphRetractResponse"]>;
 }
@@ -82,25 +40,23 @@ export declare class FactsNamespace {
      */
     importRdf(rdf: string, opts?: CallOptions & RdfImportOptions): Promise<Schemas["GraphRdfImportResponse"]>;
 }
+/**
+ * Relevance-label storage. The query surfaces this namespace once fronted were
+ * removed with their routes; SPARQL is the only query path now.
+ */
 export declare class SearchNamespace {
     private readonly client;
     constructor(client: LbbClient);
-    hybrid(query: string, opts?: HybridSearchOptions): Promise<Schemas["SemanticGraphSearchResponse"]>;
-    hybrid(body: Schemas["SemanticGraphSearchRequest"], opts?: CallOptions): Promise<Schemas["SemanticGraphSearchResponse"]>;
-    multi(body: Schemas["HybridMultiSearchRequest"], opts?: CallOptions): Promise<Schemas["HybridMultiSearchResponse"]>;
     feedback(body: Schemas["SearchFeedbackRequest"], opts?: CallOptions): Promise<Schemas["SearchFeedbackResponse"]>;
     feedbackExport(opts?: CallOptions): Promise<Schemas["SearchFeedbackExportResponse"]>;
     feedbackSummary(opts?: CallOptions): Promise<Schemas["SearchFeedbackSummaryResponse"]>;
-    fullText(body: Schemas["FullTextSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["FullTextSearchResponse"]>;
-    vector(body: Schemas["EmbeddingSearchRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["EmbeddingSearchResponse"]>;
 }
 export declare class EntityNamespace {
     private readonly client;
     constructor(client: LbbClient);
     /**
      * Return the exact type cardinality and a bounded deterministic sample from
-     * the ranged adjacency family pinned by the published generation. A missing
-     * family fails closed rather than falling back to an exhaustive scan.
+     * the Base family pinned by the published generation.
      */
     sample(opts: {
         type: string;
@@ -125,17 +81,6 @@ export declare class EntityNamespace {
      */
     filterByAttributes(opts: EntityAttributeFilterOptions): Promise<Schemas["SparqlSelectResponse"]>;
 }
-/** Grounding operations over one pinned published vocabulary. */
-export declare class ContextNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    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"]>;
-    groundability(options?: {
-        sample?: number;
-    } & CallOptions): Promise<Schemas["GroundabilityReport"]>;
-}
 /** Active ontology/SHACL bundle metadata and atomic publication. */
 export declare class SchemaNamespace {
     private readonly client;
@@ -159,12 +104,11 @@ export declare class OntologyNamespace {
     evolve(body: Schemas["OntologyEvolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyEvolveResponse"]>;
     induce(body: Schemas["OntologyInduceRequest"], opts?: CallOptions): Promise<Schemas["OntologyInduceResponse"]>;
 }
-/** Structured, SPARQL-text, and analytical query operations. */
+/** Structured and SPARQL-text query operations. */
 export declare class QueryNamespace {
     private readonly client;
     constructor(client: LbbClient);
     structured(body: Schemas["SparqlSelectRequest"], opts?: CallOptions & ReadConsistencyOptions): Promise<Schemas["SparqlSelectResponse"]>;
     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"]>;
 }