@littlebigbrain/client 0.1.0 → 0.3.0

package/dist/client.d.ts

@@ -1,298 +1,14 @@
-import type { components } from "./schema.js";
-/** Request/response types, generated from the committed OpenAPI spec. */
-export type Schemas = components["schemas"];
+import type { ImportLine, LbbClientOptions, LbbStackActivityResponse, LbbStackActivityWindow, ListResponse, RawLbbResponse, RdfExportOptions, RdfImportOptions, Schemas, SparqlResults } from "./types.js";
+import { type RequestOptions } from "./transport.js";
+import { ContextNamespace, EntityNamespace, GraphNamespace, IndexNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace } from "./namespaces.js";
+export { parseSparqlResults } from "./types.js";
+export type { AttributeFilter, AttributeFilterOp, AttributeFilterValue, EntityAttributeFilterOptions, EntityPropertiesLine, FetchLike, FlatProperties, ImportLine, LbbClientOptions, LbbRequestEvent, LbbResponseEvent, LbbErrorPayload, LbbStackActivityResponse, LbbStackActivityWindow, ListResponse, RawLbbResponse, RdfExportOptions, RdfImportOptions, Schemas, SparqlResults, SparqlResultsJson, SparqlTerm, AskRequest, AskResponse, CommitRequest, CommitResponse, Entity, EntitySelector, GraphMetadata, GraphSummary, SchemaView, SearchRequest, SearchResponse, SearchResult, Snapshot, } from "./types.js";
+export { LbbError } from "./transport.js";
+export type { CallOptions, Query, QueryValue, RequestOptions, } from "./transport.js";
+export type { EntityListOptions, HybridSearchOptions } from "./namespaces.js";
+export { ContextNamespace, EntityNamespace, FactsNamespace, GraphNamespace, IndexNamespace, OntologyNamespace, QueryNamespace, SchemaNamespace, SearchNamespace, } from "./namespaces.js";
 /**
- * The unified list-response envelope returned by every collection read
- * (`/v1/graph/entities`, `/v1/graph/edges`, `/v1/graph/observations`): the rows
- * in `data`, plus `next_cursor` (echo back as `cursor` for the next page) and
- * the pre-page `total_count`. Walk pages with {@link LbbClient.listAll}.
- */
-export interface ListResponse<T> {
-    object: "list";
-    data: T[];
-    has_more: boolean;
-    next_cursor: string | null;
-    snapshot: Schemas["SnapshotView"];
-    total_count: number;
-}
-/**
- * A flat `{ field: value }` property map. Values are coerced to each field's
- * declared type server-side, so a string like `"2026-06-26"` lands in a
- * `date_time` field and `"52"` in an `i64` field. The verbose
- * `Schemas["PropertyInput"][]` form is also accepted.
- */
-export type FlatProperties = Record<string, string | number | boolean>;
-/** A single entity-properties record for commit/import, with flat or verbose properties. */
-export type EntityPropertiesLine = {
-    type: string;
-    name: string;
-    /** Optional stable external key; identity becomes `(type, key)`. */
-    key?: string;
-    properties: FlatProperties | Schemas["PropertyInput"][];
-};
-/** One bulk-import line: a triplet, or an entity-properties record. */
-export type ImportLine = Schemas["TripletInput"] | EntityPropertiesLine;
-export type AttributeFilterOp = "eq" | "ne" | "lt" | "le" | "gt" | "ge";
-export type AttributeFilterValue = string | number | boolean | {
-    dateTime: string;
-} | {
-    entity: Schemas["EntitySelector"];
-};
-export interface AttributeFilter {
-    /** Query variable whose typed property should be compared. Defaults to the first bound pattern variable. */
-    var?: string;
-    /** Ontology property field name, e.g. `status`, `score`, or `committed_at`. */
-    field: string;
-    /** Comparison operator. Defaults to `eq`. */
-    op?: AttributeFilterOp;
-    value: AttributeFilterValue;
-}
-export interface EntityAttributeFilterOptions {
-    /** Relation patterns that bind the entity variable(s) before attribute filters run. */
-    patterns: Schemas["AnalyticTriplePattern"][];
-    /** One or more typed-property comparisons. */
-    where: AttributeFilter | AttributeFilter[];
-    /** Additional raw structured-SPARQL filters to AND with `where`. */
-    filters?: Schemas["SparqlFilter"][];
-    select?: string[];
-    limit?: number;
-    offset?: number;
-    asOfValidTime?: string;
-    asOfCommitSeq?: number;
-    orderBy?: Schemas["SparqlOrderBy"][];
-    reason?: boolean;
-    maxSolutions?: number;
-    maxObjectReads?: number;
-    maxFetchedBytes?: number;
-}
-/**
- * Minimal structural shape of `fetch`, so the client depends on neither the DOM
- * lib nor a specific runtime. Native `fetch` (Node 18+, browsers, workers)
- * satisfies it; tests can pass a fake.
- */
-export type FetchLike = (input: string, init?: {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-}) => Promise<{
-    ok: boolean;
-    status: number;
-    headers?: {
-        get(name: string): string | null;
-    };
-    text(): Promise<string>;
-}>;
-/** One term in a SPARQL result binding (the standard results-JSON term object). */
-export interface SparqlTerm {
-    type: "uri" | "literal" | "bnode" | "typed-literal";
-    value: string;
-    datatype?: string;
-    "xml:lang"?: string;
-}
-/** The standard SPARQL 1.1 Query Results JSON document. */
-export interface SparqlResultsJson {
-    head: {
-        vars?: string[];
-        link?: string[];
-    };
-    results?: {
-        bindings: Record<string, SparqlTerm>[];
-    };
-    boolean?: boolean;
-}
-/** Parsed SPARQL results: the head vars, the ASK boolean (or null), the raw
- * typed bindings, and the bindings flattened to `{ variable: lexicalValue }`. */
-export interface SparqlResults {
-    vars: string[];
-    boolean: boolean | null;
-    bindings: Record<string, SparqlTerm>[];
-    rows: Record<string, string>[];
-}
-/**
- * Parse a {@link Schemas.SparqlTextResponse} (whose `results` field carries the
- * SPARQL Results document as a JSON *string*) into typed bindings plus flat
- * `{ variable: lexicalValue }` rows — the form most callers want, so they never
- * have to `JSON.parse` and zip `head.vars` with binding values by hand.
- */
-export declare function parseSparqlResults(response: Schemas["SparqlTextResponse"]): SparqlResults;
-export interface LbbClientOptions {
-    /** Base URL of the Little Big Brain server, e.g. `https://db.eu.littlebigbrain.com`. */
-    baseUrl: string;
-    /** Stack API key (`lbb_sk_test_…` / `lbb_sk_live_…`) or single-mode token. */
-    apiKey?: string;
-    /** Graph name (sent as `?graph=`; server default is `main`). */
-    graph?: string;
-    /** Branch name (sent as `?branch=`; server default is `main`). */
-    branch?: string;
-    /**
-     * Stack slug (sent as `?stack=`). Needed only with a session-token `apiKey`
-     * (`lbb_ses_…`), which authorizes an account rather than a single stack; a
-     * stack API key (`lbb_sk_test_…` / `lbb_sk_live_…`) already fixes the stack and ignores this.
-     */
-    stack?: string;
-    /** Override the fetch implementation (defaults to the global `fetch`). */
-    fetch?: FetchLike;
-    /** API version header sent on every request. Defaults to the beta reset contract. */
-    apiVersion?: string;
-    /** Retry count for 429/5xx responses and network failures. Defaults to 2. */
-    maxRetries?: number;
-    /** Base delay between retries. Defaults to 100ms. Tests can set 0. */
-    retryDelayMs?: number;
-}
-export interface LbbStackView {
-    stack_id: string;
-    owner_id?: string;
-    name: string;
-    slug: string;
-    tenant_id: string;
-    default_graph: string;
-    default_branch: string;
-    created_at_micros: number;
-    api_key_hint: string;
-    api_key_rotated_at_micros: number;
-}
-export interface LbbAdminStackCreateRequest {
-    owner_id: string;
-    name: string;
-    slug?: string;
-}
-export interface LbbAdminStackResponse {
-    ok: true;
-    stack: LbbStackView;
-    api_key?: string;
-    active_api_key_count?: number;
-}
-export type LbbStackActivityWindow = "1h" | "4h" | "12h" | "24h";
-export interface LbbStackActivityResponse {
-    ok: true;
-    stack: {
-        slug: string;
-        name?: string;
-    };
-    window: {
-        range: LbbStackActivityWindow;
-        from_micros: number;
-        to_micros: number;
-        bucket_seconds: number;
-        freshness_seconds: number;
-    };
-    totals: {
-        requests: number;
-        errors: number;
-        p50_latency_ms: number;
-        p95_latency_ms: number;
-        p99_latency_ms: number;
-        storage_read_ops: number;
-        storage_read_bytes: number;
-        storage_write_ops: number;
-        storage_write_bytes: number;
-        index_read_ops: number;
-        index_read_bytes: number;
-    };
-    details: {
-        total_bucket_count: number;
-        active_bucket_count: number;
-        error_rate: number;
-        storage_total_ops: number;
-        storage_total_bytes: number;
-        non_index_storage_read_ops: number;
-        non_index_storage_read_bytes: number;
-        index_read_share: number;
-        first_activity_bucket_start_micros?: number;
-        last_activity_bucket_start_micros?: number;
-    };
-    series: Array<{
-        bucket_start_micros: number;
-        requests: number;
-        errors: number;
-        p50_latency_ms: number;
-        p95_latency_ms: number;
-        p99_latency_ms: number;
-        storage_read_ops: number;
-        storage_read_bytes: number;
-        storage_write_ops: number;
-        storage_write_bytes: number;
-        index_read_ops: number;
-        index_read_bytes: number;
-    }>;
-    routes: Array<{
-        family: string;
-        requests: number;
-        errors: number;
-        error_rate: number;
-        request_share: number;
-        p50_latency_ms: number;
-        p95_latency_ms: number;
-        p99_latency_ms: number;
-    }>;
-    storage: Array<{
-        family: string;
-        read_ops: number;
-        read_bytes: number;
-        write_ops: number;
-        write_bytes: number;
-        total_ops: number;
-        total_bytes: number;
-        op_share: number;
-        byte_share: number;
-    }>;
-    partial: boolean;
-}
-export interface LbbAdminSessionResponse {
-    ok: true;
-    /** A `lbb_ses_…` session token scoped to the account. */
-    token: string;
-    expires_at_micros: number;
-}
-export interface LbbAdminStackDeleteResponse {
-    ok: true;
-    deleted_stack: LbbStackView;
-    tenant_prefix: string;
-    objects_deleted: number;
-    bytes_deleted: number;
-}
-export interface LbbErrorPayload {
-    type?: string;
-    code?: string;
-    message?: string;
-    param?: string | null;
-    request_id?: string | null;
-    doc_url?: string | null;
-}
-export interface RawLbbResponse<T> {
-    data: T;
-    status: number;
-    requestId?: string;
-    version?: string;
-    headers?: {
-        get(name: string): string | null;
-    };
-}
-export interface RequestOptions {
-    query?: Query;
-    body?: unknown;
-    /** Pre-serialized request body (e.g. NDJSON). Takes precedence over `body`. */
-    rawBody?: string;
-    /** Overrides the default `application/json` content type (used with `rawBody`). */
-    contentType?: string;
-    idempotencyKey?: string;
-}
-/** Thrown when the server responds with a non-2xx status. */
-export declare class LbbError extends Error {
-    readonly status: number;
-    readonly body: string;
-    readonly error?: LbbErrorPayload | undefined;
-    readonly type?: string;
-    readonly code?: string;
-    readonly param?: string | null;
-    readonly requestId?: string | null;
-    readonly docUrl?: string | null;
-    constructor(status: number, body: string, error?: LbbErrorPayload | undefined);
-}
-type QueryValue = string | number | boolean | undefined;
-type Query = Record<string, QueryValue>;
-/**
- * A typed HTTP client for a Little Big Brain graph server. One instance is scoped to a
+ * 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
  * return the parsed JSON response and throw {@link LbbError} on failure.
  */
@@ -306,10 +22,16 @@ export declare class LbbClient {
     private readonly apiVersion;
     private readonly maxRetries;
     private readonly retryDelayMs;
+    private readonly timeoutMs;
+    private readonly onRequest?;
+    private readonly onResponse?;
+    readonly context: ContextNamespace;
     readonly search: SearchNamespace;
     readonly indexes: IndexNamespace;
     readonly entities: EntityNamespace;
     readonly schema: SchemaNamespace;
+    readonly ontology: OntologyNamespace;
+    readonly query: QueryNamespace;
     constructor(options: LbbClientOptions);
     graph(name: string, opts?: {
         branch?: string;
@@ -348,26 +70,29 @@ export declare class LbbClient {
      * bounded internal commits server-side, so a whole dataset loads in one
      * 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.
      */
     import(lines: ImportLine[] | string, opts?: {
         batch?: number;
         strict?: boolean;
         observedAt?: string;
+        index?: boolean;
         idempotencyKey?: string;
     }): Promise<Schemas["GraphImportResponse"]>;
     /**
-     * Bulk-ingest N-Triples without client-side conversion. Resource-object
+     * 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
      * properties on the subject Resource.
      */
-    importRdf(ntriples: string, opts?: {
-        batch?: number;
-        strict?: boolean;
-        observedAt?: string;
-        resourceType?: string;
-        edgeIdempotency?: "append" | "skip_unchanged";
-        idempotencyKey?: string;
-    }): Promise<Schemas["GraphRdfImportResponse"]>;
+    importRdf(rdf: string, opts?: RdfImportOptions): Promise<Schemas["GraphRdfImportResponse"]>;
+    /** Export the snapshot-visible RDF projection as Turtle, N-Triples, TriG, or N-Quads. */
+    exportRdf(opts?: RdfExportOptions): Promise<string>;
     /**
      * Retract specific edges and/or every edge touching given entities. Appends
      * superseding retract events rather than deleting — history stays visible in an
@@ -381,6 +106,23 @@ export declare class LbbClient {
     createGraph(): Promise<Schemas["CreateGraphResponse"]>;
     /** Fork the scoped branch from an existing branch in the same graph. */
     createBranch(body: Schemas["GraphBranchCreateRequest"]): Promise<Schemas["GraphBranchCreateResponse"]>;
+    /**
+     * Validate-then-merge: replay `from_branch`'s post-fork commits onto the
+     * SCOPED branch (its fork parent) as one new commit. A write — sends an
+     * Idempotency-Key so a retry replays instead of re-applying.
+     */
+    mergeBranch(body: Schemas["GraphBranchMergeRequest"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["GraphBranchMergeResponse"]>;
+    /**
+     * Observe: store a conversation episode verbatim as EPISODE evidence,
+     * anchor + gate extracted facts on an observe branch, and optionally
+     * auto-merge when validation is clean. Flag-gated server-side
+     * (`--enable-observe`). A write — carries an Idempotency-Key.
+     */
+    observe(body: Schemas["ObserveRequest"], opts?: {
+        idempotencyKey?: string;
+    }): Promise<Schemas["ObserveResponse"]>;
     /**
      * Delete every object under the scoped graph/branch — a destructive reset.
      * `confirm` must equal the scoped graph id; the next commit re-initializes the
@@ -389,12 +131,178 @@ export declare class LbbClient {
     deleteGraph(opts: {
         confirm: string;
     }): Promise<unknown>;
+    /**
+     * 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,
+     * eval > T).
+     */
+    readSignals(opts?: {
+        from?: number;
+        to?: number;
+        limit?: number;
+    }): Promise<Schemas["SignalReadResponse"]>;
+    /**
+     * Record one immutable model-as-run manifest; runs number sequentially per
+     * kind. Trainers MUST train on data ≤ `trained_at_commit_seq` and evaluate
+     * past it — `modelSplitAudit` verifies the recorded lineage.
+     */
+    recordModelRun(body: Schemas["ModelRunManifest"]): Promise<{
+        run: number;
+    }>;
+    /** CAS-promote a recorded run to CURRENT for its kind (replay is a no-op). */
+    promoteModelRun(opts: {
+        kind: string;
+        run: number;
+    }): Promise<unknown>;
+    /** A kind's model runs, newest first, with effective promotion state. */
+    modelRegistry(opts: {
+        kind: string;
+    }): Promise<Schemas["ModelRegistryResponse"]>;
+    /** GC run prefixes beyond the promoted run + the last `keep`; reports deletions. */
+    modelRegistryGc(opts: {
+        kind: string;
+        keep?: number;
+    }): Promise<unknown>;
+    /** Verify a run's temporal-split obligation from its recorded lineage. */
+    modelSplitAudit(opts: {
+        kind: string;
+        run: number;
+    }): Promise<Schemas["ModelSplitAudit"]>;
+    /**
+     * Champion vs challenger retrieval over one pinned snapshot. Returns
+     * promotion evidence (hit-rate@k, latency, overlap); never promotes.
+     */
+    shadowEval(body: Schemas["ShadowEvalRequest"]): Promise<Schemas["ShadowEvalResponse"]>;
+    /**
+     * 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.
+     */
+    syntheticEval(opts?: {
+        limit?: number;
+    }): Promise<Schemas["SyntheticEvalResponse"]>;
+    /** The doubling retrain policy: is a retrain due for this model kind? */
+    modelCadence(opts: {
+        kind: string;
+    }): Promise<Schemas["ModelCadenceResponse"]>;
+    /**
+     * One deterministic trainer tick: build a probe set (execution-verified
+     * synthetic pairs, or bring your own), search a bounded candidate space on
+     * the train slice, gate the winner against the champion on the held-out
+     * eval slice, record the run either way, and promote only when the gate
+     * passes. The same tick the `auto_train` cadence fires — always safe to
+     * call by hand.
+     */
+    trainTick(body: Schemas["TrainModelRequest"]): Promise<Schemas["TrainModelResponse"]>;
+    /** The graph's automatic-training configuration (default: off). */
+    trainingConfig(): Promise<Schemas["ModelTrainingConfig"]>;
+    /** Set the automatic-training configuration (`auto_train` toggle + kinds). */
+    setTrainingConfig(body: Schemas["ModelTrainingConfig"]): Promise<Schemas["ModelTrainingConfig"]>;
+    /**
+     * 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: Schemas["AskFeedbackRequest"]): Promise<Schemas["AskFeedbackResponse"]>;
+    /**
+     * 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.
+     */
+    plannerDataset(opts?: {
+        limit?: number;
+        splitSeq?: number;
+    }): Promise<Schemas["PlannerDatasetResponse"]>;
+    /**
+     * The DPO pass's training feed: preference pairs from corrected verdicts,
+     * paired rejections, and synthetic corrupted-slot pairs.
+     */
+    plannerPreferenceDataset(opts?: {
+        limit?: number;
+        splitSeq?: number;
+    }): Promise<Schemas["PlannerPreferenceDatasetResponse"]>;
+    /**
+     * 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.
+     */
+    suggestDataset(opts?: {
+        limit?: number;
+        splitSeq?: number;
+    }): Promise<Schemas["SuggestDatasetResponse"]>;
+    /**
+     * The extractor fine-tune's training feed: EPISODE transcripts joined to
+     * the facts the observe pipeline committed from them.
+     */
+    extractorDataset(opts?: {
+        limit?: number;
+        splitSeq?: number;
+    }): Promise<Schemas["ExtractorDatasetResponse"]>;
+    /**
+     * Promote a finished `extractor_lora` training run: gated on held-out fact
+     * F1, recorded as a `kind=extractor` training run whose adapter resident
+     * extraction then serves.
+     */
+    promoteExtractor(opts: {
+        runId: string;
+        allowRegression?: boolean;
+    }): Promise<unknown>;
+    /**
+     * 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.
+     */
+    promotePlanner(opts: {
+        runId: string;
+        allowRegression?: boolean;
+    }): Promise<unknown>;
     /** Full semantic hybrid search from a request body (`POST /v1/graph/search`). */
     graphSearch(body: Schemas["SemanticGraphSearchRequest"]): Promise<Schemas["SemanticGraphSearchResponse"]>;
     /** Reciprocal-rank-fusion across sub-queries. */
     multiSearch(body: Schemas["HybridMultiSearchRequest"]): Promise<Schemas["HybridMultiSearchResponse"]>;
     /**
-     * Append relevance labels for a set of search results — how Little Big Brain
+     * 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 real vocabulary item. Embedding cosine
+     * on a managed graph, else lexical; never fabricates a term.
+     */
+    resolveTerm(body: Schemas["ResolveTermRequest"]): Promise<Schemas["ResolveTermResponse"]>;
+    /**
+     * Ground a natural-language question to the graph's real vocabulary, retrieve
+     * against the pinned snapshot, and answer with citations (`/v1/ask`).
+     */
+    ask(body: Schemas["AskRequest"]): Promise<Schemas["AskResponse"]>;
+    /**
+     * 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(body: Schemas["DecodeRequest"]): Promise<Schemas["DecodeResponse"]>;
+    /**
+     * Report which completion mechanisms will carry on this graph:
+     * signature sparsity, name semantics, sampled narrowing recall, and a
+     * narrow / narrow+finetune / lexical-first recommendation.
+     */
+    groundability(opts?: {
+        sample?: number;
+    }): Promise<Schemas["GroundabilityReport"]>;
+    /**
+     * Append relevance labels for a set of search 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
@@ -529,7 +437,7 @@ export declare class LbbClient {
     /** The rule set stored on the scoped graph branch (version + rules). */
     graphRules(): Promise<Schemas["RuleSet"]>;
     /**
-     * Stage G — derive edges from calibrated retrieval matches (preview): each
+     * 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.
@@ -604,161 +512,6 @@ export declare class LbbClient {
     summary(): Promise<Schemas["GraphSummaryResponse"]>;
     /** List the graphs (and branches) under the scoped tenant. */
     listGraphs(): Promise<Schemas["GraphListResponse"]>;
-    /** Create a database stack and return its one-time stack API key. */
-    adminCreateStack(body: LbbAdminStackCreateRequest): Promise<LbbAdminStackResponse>;
-    /** Inspect a database stack without returning secret key material. */
-    adminStack(slug: string): Promise<LbbAdminStackResponse>;
-    /** Rotate a database stack key and return the new one-time API key. */
-    adminRotateStackKey(slug: string): Promise<LbbAdminStackResponse>;
-    /** Delete a database stack after confirming the slug. */
-    adminDeleteStack(slug: string): Promise<LbbAdminStackDeleteResponse>;
-    /**
-     * Mint a short-lived `lbb_ses_…` session token for an account. A trusted
-     * co-located service uses it (with `?stack=<slug>`) to call the data plane on
-     * the account's behalf without handling the stack's mode-bearing stack key.
-     */
-    adminMintSession(accountId: string): Promise<LbbAdminSessionResponse>;
-    /** Customer-visible activity for one database stack. */
-    adminStackActivity(slug: string, window?: LbbStackActivityWindow): Promise<LbbStackActivityResponse>;
     /** Activity for the stack selected by the bearer stack key or session. */
     stackActivity(window?: LbbStackActivityWindow): Promise<LbbStackActivityResponse>;
 }
-export declare class GraphNamespace {
-    private readonly client;
-    readonly facts: FactsNamespace;
-    constructor(client: LbbClient);
-    branch(name: string): GraphNamespace;
-    create(): Promise<Schemas["CreateGraphResponse"]>;
-    delete(opts: {
-        confirm: string;
-    }): Promise<unknown>;
-    /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
-    retract(body: Schemas["GraphRetractRequest"], opts?: {
-        idempotencyKey?: string;
-    }): Promise<Schemas["GraphRetractResponse"]>;
-}
-export declare class FactsNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    create(body: Schemas["TripletCommitFile"], opts?: {
-        idempotencyKey?: string;
-    }): Promise<Schemas["GraphCommitResponse"]>;
-    /** Bulk-load a dataset as NDJSON. See {@link LbbClient.import}. */
-    import(lines: ImportLine[] | string, opts?: {
-        batch?: number;
-        strict?: boolean;
-        observedAt?: string;
-        idempotencyKey?: string;
-    }): Promise<Schemas["GraphImportResponse"]>;
-    /**
-     * Bulk-load N-Triples through the native RDF import endpoint.
-     *
-     * Statements are committed through the fixed RDF_TRIPLE relation; source RDF
-     * predicates and literal term details are preserved as edge metadata.
-     */
-    importRdf(ntriples: string, opts?: {
-        batch?: number;
-        strict?: boolean;
-        observedAt?: string;
-        resourceType?: string;
-        edgeIdempotency?: "append" | "skip_unchanged";
-        idempotencyKey?: string;
-    }): Promise<Schemas["GraphRdfImportResponse"]>;
-}
-export declare class SearchNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    hybrid(query: string, opts?: {
-        topK?: number;
-        source?: string;
-        consistency?: string;
-        lexical?: boolean;
-        bm25?: boolean;
-        vector?: boolean;
-        targets?: string[];
-        profile?: string;
-        /** Opt-in impression logging (L1): durably record this search's full
-         * ranking context, keyed by `search_id`, so a later feedback label on it
-         * carries the ranking it was judged against. Off by default. */
-        logImpression?: boolean;
-    }): Promise<Schemas["SemanticGraphSearchResponse"]>;
-    hybrid(body: Schemas["SemanticGraphSearchRequest"]): Promise<Schemas["SemanticGraphSearchResponse"]>;
-    multi(body: Schemas["HybridMultiSearchRequest"]): Promise<Schemas["HybridMultiSearchResponse"]>;
-    feedback(body: Schemas["SearchFeedbackRequest"], opts?: {
-        idempotencyKey?: string;
-    }): Promise<Schemas["SearchFeedbackResponse"]>;
-    feedbackExport(): Promise<Schemas["SearchFeedbackExportResponse"]>;
-    fullText(body: Schemas["FullTextSearchRequest"]): Promise<Schemas["FullTextSearchResponse"]>;
-    vector(body: Schemas["EmbeddingSearchRequest"]): 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;
-    }): Promise<Schemas["SchemaBundleView"]>;
-    /** Preview a proposed RDF/SHACL schema bundle and audit current data. */
-    preview(body: Schemas["SchemaPreviewRequest"]): Promise<Schemas["SchemaPreviewResponse"]>;
-    /** Activate a previewed SHACL schema bundle for this graph branch. */
-    publish(body: Schemas["SchemaPublishRequest"]): Promise<Schemas["SchemaPublishResponse"]>;
-    /** Audit current data against the active SHACL schema bundle. */
-    audit(): Promise<Schemas["SchemaAuditReport"]>;
-}
-export declare class IndexNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    run(opts?: {
-        wait?: boolean;
-        background?: boolean;
-        body?: unknown;
-    }): Promise<unknown>;
-    build(): Promise<unknown>;
-    delta(): Promise<Schemas["IndexDeltaResponse"]>;
-    gc(opts?: {
-        keepRuns?: number;
-        dryRun?: boolean;
-    }): Promise<Schemas["IndexGcResponse"]>;
-}
-export declare class EntityNamespace {
-    private readonly client;
-    constructor(client: LbbClient);
-    /**
-     * 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?: {
-        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[];
-    }): Promise<ListResponse<Schemas["EntityExplorerRow"]>>;
-    get(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-        asOf?: string;
-    }): Promise<Schemas["EntityMetadataResponse"]>;
-    detail(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-    }): Promise<Schemas["EntityDetailResponse"]>;
-    /**
-     * Filter entities already bound by relation patterns using typed attributes,
-     * without writing RDF property IRIs by hand. This is a convenience wrapper over
-     * the structured SPARQL route: relation `patterns` bind variables, and `where`
-     * compares ontology property fields on those bound variables.
-     */
-    filterByAttributes(opts: EntityAttributeFilterOptions): Promise<Schemas["SparqlSelectResponse"]>;
-}
-export {};