@littlebigbrain/client 0.1.0 → 0.3.0

package/dist/client.js

@@ -1,114 +1,11 @@
+import { parseSparqlResults } from "./types.js";
+import { parseLbbError, parseResponseJson, retryAllowed, retryDelayForAttempt, retryableStatus, sleep, } from "./transport.js";
+import { ContextNamespace, EntityNamespace, GraphNamespace, IndexNamespace, 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";
 /**
- * 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 function parseSparqlResults(response) {
-    const doc = JSON.parse(response.results);
-    const vars = doc.head?.vars ?? [];
-    if (typeof doc.boolean === "boolean") {
-        return { vars, boolean: doc.boolean, bindings: [], rows: [] };
-    }
-    const bindings = doc.results?.bindings ?? [];
-    const rows = bindings.map((binding) => Object.fromEntries(Object.entries(binding).map(([name, term]) => [name, term.value])));
-    return { vars, boolean: null, bindings, rows };
-}
-function firstPatternVariable(patterns) {
-    for (const pattern of patterns) {
-        if ("var" in pattern.subject)
-            return pattern.subject.var;
-        if ("var" in pattern.object)
-            return pattern.object.var;
-    }
-    return "entity";
-}
-function attributeFilterValue(value) {
-    if (typeof value === "boolean")
-        return { bool: value };
-    if (typeof value === "number")
-        return Number.isInteger(value) ? { i64: value } : { f64: value };
-    if (typeof value === "string")
-        return { str: value };
-    if ("dateTime" in value)
-        return { date_time: value.dateTime };
-    return { entity: value.entity };
-}
-function attributeFilter(filter, defaultVar) {
-    return {
-        compare: {
-            op: filter.op ?? "eq",
-            left: { property: { var: filter.var ?? defaultVar, field: filter.field } },
-            right: { value: attributeFilterValue(filter.value) },
-        },
-    };
-}
-/** Thrown when the server responds with a non-2xx status. */
-export class LbbError extends Error {
-    status;
-    body;
-    error;
-    type;
-    code;
-    param;
-    requestId;
-    docUrl;
-    constructor(status, body, error) {
-        super(error?.message ?? `Little Big Brain ${status}: ${body}`);
-        this.status = status;
-        this.body = body;
-        this.error = error;
-        this.name = "LbbError";
-        this.type = error?.type;
-        this.code = error?.code;
-        this.param = error?.param;
-        this.requestId = error?.request_id;
-        this.docUrl = error?.doc_url;
-    }
-}
-function sleep(ms) {
-    if (ms <= 0)
-        return Promise.resolve();
-    const timer = globalThis
-        .setTimeout;
-    return new Promise((resolve) => {
-        if (timer) {
-            timer(resolve, ms);
-        }
-        else {
-            resolve();
-        }
-    });
-}
-function retryableStatus(status) {
-    return status === 429 || status >= 500;
-}
-function retryAllowed(method, idempotencyKey) {
-    const upper = method.toUpperCase();
-    return upper === "GET" || upper === "HEAD" || upper === "OPTIONS" || idempotencyKey !== undefined;
-}
-function parseLbbError(status, body, fallbackRequestId) {
-    try {
-        const parsed = JSON.parse(body);
-        if (parsed.error) {
-            return new LbbError(status, body, {
-                ...parsed.error,
-                request_id: parsed.error.request_id ?? fallbackRequestId ?? null,
-            });
-        }
-    }
-    catch {
-        // Fall through to an unstructured error.
-    }
-    return new LbbError(status, body, {
-        type: "api_error",
-        code: "unstructured_error",
-        message: body || `Little Big Brain ${status}`,
-        request_id: fallbackRequestId ?? null,
-    });
-}
-/**
- * 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.
  */
@@ -122,10 +19,16 @@ export class LbbClient {
     apiVersion;
     maxRetries;
     retryDelayMs;
+    timeoutMs;
+    onRequest;
+    onResponse;
+    context;
     search;
     indexes;
     entities;
     schema;
+    ontology;
+    query;
     constructor(options) {
         this.baseUrl = options.baseUrl.replace(/\/+$/, "");
         this.apiKey = options.apiKey;
@@ -135,16 +38,31 @@ export class LbbClient {
         this.apiVersion = options.apiVersion ?? "2026-06-22";
         this.maxRetries = options.maxRetries ?? 2;
         this.retryDelayMs = options.retryDelayMs ?? 100;
+        this.timeoutMs = options.timeoutMs ?? 120_000;
+        this.onRequest = options.onRequest;
+        this.onResponse = options.onResponse;
+        if (!Number.isInteger(this.maxRetries) || this.maxRetries < 0) {
+            throw new RangeError("maxRetries must be a non-negative integer");
+        }
+        if (!Number.isFinite(this.retryDelayMs) || this.retryDelayMs < 0) {
+            throw new RangeError("retryDelayMs must be a non-negative number");
+        }
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs < 0) {
+            throw new RangeError("timeoutMs must be a non-negative number");
+        }
         const fallback = globalThis.fetch;
         const chosen = options.fetch ?? (fallback ? fallback.bind(globalThis) : undefined);
         if (!chosen) {
             throw new Error("no fetch implementation available; pass options.fetch");
         }
         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);
+        this.query = new QueryNamespace(this);
     }
     graph(name, opts = {}) {
         return new GraphNamespace(this.withScope({
@@ -169,6 +87,9 @@ export class LbbClient {
             apiVersion: this.apiVersion,
             maxRetries: this.maxRetries,
             retryDelayMs: this.retryDelayMs,
+            timeoutMs: this.timeoutMs,
+            onRequest: this.onRequest,
+            onResponse: this.onResponse,
         });
     }
     buildUrl(path, query) {
@@ -196,7 +117,8 @@ export class LbbClient {
             headers["authorization"] = `Bearer ${this.apiKey}`;
         if (opts.idempotencyKey !== undefined)
             headers["idempotency-key"] = opts.idempotencyKey;
-        const canRetry = retryAllowed(method, opts.idempotencyKey);
+        Object.assign(headers, opts.headers ?? {});
+        const canRetry = opts.retry ?? retryAllowed(method, opts.idempotencyKey);
         const body = opts.rawBody !== undefined
             ? opts.rawBody
             : opts.body !== undefined
@@ -207,40 +129,106 @@ export class LbbClient {
             headers,
             body,
         };
+        const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+        const maxRetries = opts.maxRetries ?? this.maxRetries;
+        if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+            throw new RangeError("maxRetries must be a non-negative integer");
+        }
+        const startedAt = Date.now();
+        const url = this.buildUrl(path, opts.query);
+        let attempts = 0;
         let response;
         let text = "";
-        for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+            if (opts.signal?.aborted)
+                throw opts.signal.reason ?? new Error("request aborted");
+            attempts = attempt + 1;
+            const controller = (timeoutMs > 0 || opts.signal) && typeof AbortController !== "undefined"
+                ? new AbortController()
+                : undefined;
+            const abortFromCaller = () => controller?.abort(opts.signal?.reason);
+            opts.signal?.addEventListener("abort", abortFromCaller, { once: true });
+            const timer = controller
+                ? timeoutMs > 0
+                    ? setTimeout(() => controller.abort(), timeoutMs)
+                    : undefined
+                : undefined;
             try {
-                response = await this.fetchImpl(this.buildUrl(path, opts.query), init);
+                this.onRequest?.({
+                    method: method.toUpperCase(),
+                    url,
+                    attempt: attempts,
+                    maxAttempts: maxRetries + 1,
+                    idempotencyKey: opts.idempotencyKey,
+                });
+                response = await this.fetchImpl(url, {
+                    ...init,
+                    signal: controller?.signal ?? opts.signal,
+                });
                 text = await response.text();
             }
             catch (error) {
-                if (canRetry && attempt < this.maxRetries) {
+                const callerAborted = opts.signal?.aborted === true;
+                const requestError = controller?.signal.aborted && !callerAborted
+                    ? Object.assign(new Error(`Little Big Brain request timed out after ${timeoutMs}ms`, {
+                        cause: error,
+                    }), { name: "TimeoutError" })
+                    : error;
+                if (!callerAborted && canRetry && attempt < maxRetries) {
                     await sleep(this.retryDelayMs * (attempt + 1));
                     continue;
                 }
-                throw error;
+                throw requestError;
             }
-            if (response.ok || !retryableStatus(response.status) || attempt === this.maxRetries) {
+            finally {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                opts.signal?.removeEventListener("abort", abortFromCaller);
+            }
+            if (response.ok ||
+                !retryableStatus(response.status) ||
+                attempt === maxRetries) {
                 break;
             }
             if (!canRetry) {
                 break;
             }
-            await sleep(this.retryDelayMs * (attempt + 1));
+            await sleep(retryDelayForAttempt(this.retryDelayMs, attempt, response.headers?.get("retry-after")));
         }
         if (response === undefined)
             throw new Error("request did not produce a response");
         const requestId = response.headers?.get("x-request-id") ?? undefined;
         const version = response.headers?.get("lbb-version") ?? undefined;
+        const elapsedMs = Math.max(0, Date.now() - startedAt);
+        this.onResponse?.({
+            method: method.toUpperCase(),
+            url,
+            status: response.status,
+            requestId,
+            attempts,
+            retryCount: Math.max(0, attempts - 1),
+            elapsedMs,
+        });
         if (!response.ok)
             throw parseLbbError(response.status, text.trim(), requestId);
+        const responseContentType = response.headers?.get("content-type")?.toLowerCase() ?? "";
+        const isRdfText = responseContentType.includes("text/turtle") ||
+            responseContentType.includes("application/n-triples") ||
+            responseContentType.includes("application/trig") ||
+            responseContentType.includes("application/n-quads");
         return {
-            data: (text ? JSON.parse(text) : undefined),
+            data: text
+                ? isRdfText
+                    ? text
+                    : parseResponseJson(text, response.status, requestId)
+                : undefined,
             status: response.status,
             requestId,
             version,
             headers: response.headers,
+            attempts,
+            retryCount: Math.max(0, attempts - 1),
+            elapsedMs,
         };
     }
     async request(method, path, opts = {}) {
@@ -281,6 +269,13 @@ export 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, opts = {}) {
         const ndjson = typeof lines === "string"
@@ -289,28 +284,56 @@ export class LbbClient {
         return this.request("POST", "/v1/graph/import", {
             rawBody: ndjson,
             contentType: "application/x-ndjson",
-            query: { batch: opts.batch, strict: opts.strict, observed_at: opts.observedAt },
-            idempotencyKey: opts.idempotencyKey,
+            query: {
+                batch: opts.batch,
+                strict: opts.strict,
+                observed_at: opts.observedAt,
+                index: opts.index,
+            },
+            idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("import"),
         });
     }
     /**
-     * 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, opts = {}) {
+    importRdf(rdf, opts = {}) {
+        const format = opts.format ?? "ntriples";
+        const contentTypes = {
+            ntriples: "application/n-triples",
+            turtle: "text/turtle",
+            nquads: "application/n-quads",
+            trig: "application/trig",
+        };
         return this.request("POST", "/v1/graph/import/rdf", {
-            rawBody: ntriples,
-            contentType: "application/n-triples",
+            rawBody: rdf,
+            contentType: contentTypes[format],
             query: {
                 batch: opts.batch,
                 strict: opts.strict,
                 observed_at: opts.observedAt,
-                format: "ntriples",
+                format,
+                base_iri: opts.baseIri,
+                graph_uri: opts.graphUri,
+                blank_node_scope: opts.blankNodeScope,
                 resource_type: opts.resourceType,
                 edge_idempotency: opts.edgeIdempotency,
             },
-            idempotencyKey: opts.idempotencyKey,
+            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,
+            },
         });
     }
     /**
@@ -333,13 +356,200 @@ export class LbbClient {
     createBranch(body) {
         return this.request("POST", "/v1/graph/branch", { body });
     }
+    /**
+     * 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, opts = {}) {
+        return this.request("POST", "/v1/graph/branch/merge", {
+            body,
+            idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("branch-merge"),
+        });
+    }
+    /**
+     * 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, opts = {}) {
+        return this.request("POST", "/v1/memory/observe", {
+            body,
+            idempotencyKey: opts.idempotencyKey ?? this.idempotencyKey("observe"),
+        });
+    }
     /**
      * Delete every object under the scoped graph/branch — a destructive reset.
      * `confirm` must equal the scoped graph id; the next commit re-initializes the
      * graph. Branch-scoped: sibling branches are untouched.
      */
     deleteGraph(opts) {
-        return this.request("POST", "/v1/graph/delete", { query: { confirm: opts.confirm } });
+        return this.request("POST", "/v1/graph/delete", {
+            query: { confirm: opts.confirm },
+        });
+    }
+    // --- 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,
+     * eval > T).
+     */
+    readSignals(opts = {}) {
+        return this.request("GET", "/v1/signals", {
+            query: { from: opts.from, to: opts.to, limit: opts.limit },
+        });
+    }
+    /**
+     * 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) {
+        return this.request("POST", "/v1/models/record", { body });
+    }
+    /** CAS-promote a recorded run to CURRENT for its kind (replay is a no-op). */
+    promoteModelRun(opts) {
+        return this.request("POST", "/v1/models/promote", {
+            query: { kind: opts.kind, run: opts.run },
+        });
+    }
+    /** A kind's model runs, newest first, with effective promotion state. */
+    modelRegistry(opts) {
+        return this.request("GET", "/v1/models/registry", {
+            query: { kind: opts.kind },
+        });
+    }
+    /** GC run prefixes beyond the promoted run + the last `keep`; reports deletions. */
+    modelRegistryGc(opts) {
+        return this.request("POST", "/v1/models/registry/gc", {
+            query: { kind: opts.kind, keep: opts.keep },
+        });
+    }
+    /** Verify a run's temporal-split obligation from its recorded lineage. */
+    modelSplitAudit(opts) {
+        return this.request("GET", "/v1/models/split-audit", {
+            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.
+     */
+    syntheticEval(opts = {}) {
+        return this.request("GET", "/v1/models/synthetic-eval", {
+            query: { limit: opts.limit },
+        });
+    }
+    /** The doubling retrain policy: is a retrain due for this model kind? */
+    modelCadence(opts) {
+        return this.request("GET", "/v1/models/cadence", {
+            query: { kind: opts.kind },
+        });
+    }
+    /**
+     * 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) {
+        return this.request("POST", "/v1/models/train-tick", { body });
+    }
+    /** The graph's automatic-training configuration (default: off). */
+    trainingConfig() {
+        return this.request("GET", "/v1/models/training-config", {});
+    }
+    /** Set the automatic-training configuration (`auto_train` toggle + kinds). */
+    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) {
+        return this.request("POST", "/v1/ask/feedback", { body });
+    }
+    /**
+     * 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 = {}) {
+        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.
+     */
+    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.
+     */
+    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.
+     */
+    extractorDataset(opts = {}) {
+        return this.request("GET", "/v1/models/extractor-dataset", {
+            query: { limit: opts.limit, split_seq: opts.splitSeq },
+        });
+    }
+    /**
+     * 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) {
+        return this.request("POST", "/v1/models/promote-extractor", {
+            query: { run_id: opts.runId, allow_regression: opts.allowRegression },
+        });
+    }
+    /**
+     * 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) {
+        return this.request("POST", "/v1/models/promote-planner", {
+            query: { run_id: opts.runId, allow_regression: opts.allowRegression },
+        });
     }
     // --- search ---
     /** Full semantic hybrid search from a request body (`POST /v1/graph/search`). */
@@ -351,7 +561,48 @@ export class LbbClient {
         return this.request("POST", "/v1/search/multi", { body });
     }
     /**
-     * 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) {
+        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.
+     */
+    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(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.
+     */
+    groundability(opts = {}) {
+        return this.request("GET", "/v1/graph/groundability", {
+            query: opts.sample != null ? { sample: String(opts.sample) } : undefined,
+        });
+    }
+    /**
+     * 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
@@ -549,7 +800,7 @@ export class LbbClient {
         return this.request("GET", "/v1/inference/rules");
     }
     /**
-     * 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.
@@ -609,7 +860,9 @@ export class LbbClient {
      * timeout (a 504), then poll `metadata()` for completion.
      */
     indexBuild(opts = {}) {
-        return this.request("POST", "/v1/index/build", { query: { background: opts.background || undefined } });
+        return this.request("POST", "/v1/index/build", {
+            query: { background: opts.background || undefined },
+        });
     }
     /**
      * Build BM25, ANN/vector, and adjacency index families. With
@@ -618,7 +871,9 @@ export class LbbClient {
      * 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 } });
+        return this.request("POST", "/v1/index/run", {
+            query: { background: opts.background || undefined },
+        });
     }
     /** Append a BM25 delta segment for the unindexed WAL tail. */
     indexDelta() {
@@ -633,7 +888,10 @@ export class LbbClient {
     /** Fold the WAL tail into snapshot segments. */
     compact(opts = {}) {
         return this.request("POST", "/v1/graph/compact", {
-            query: { min_tail_commits: opts.minTailCommits, max_segments: opts.maxSegments },
+            query: {
+                min_tail_commits: opts.minTailCommits,
+                max_segments: opts.maxSegments,
+            },
         });
     }
     // --- inspection ---
@@ -653,226 +911,9 @@ export class LbbClient {
     listGraphs() {
         return this.request("GET", "/v1/graphs");
     }
-    // --- database admin ---
-    /** Create a database stack and return its one-time stack API key. */
-    adminCreateStack(body) {
-        return this.request("POST", "/api/admin/stacks", { body });
-    }
-    /** Inspect a database stack without returning secret key material. */
-    adminStack(slug) {
-        return this.request("GET", "/api/admin/stacks", { query: { stack: slug } });
-    }
-    /** Rotate a database stack key and return the new one-time API key. */
-    adminRotateStackKey(slug) {
-        return this.request("POST", "/api/admin/stacks/rotate-key", { query: { stack: slug } });
-    }
-    /** Delete a database stack after confirming the slug. */
-    adminDeleteStack(slug) {
-        return this.request("DELETE", "/api/admin/stacks", { query: { stack: slug, confirm: slug } });
-    }
-    /**
-     * 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) {
-        return this.request("POST", "/api/admin/sessions", { body: { account_id: accountId } });
-    }
-    /** Customer-visible activity for one database stack. */
-    adminStackActivity(slug, window = "24h") {
-        return this.request("GET", "/api/admin/stacks/activity", { query: { stack: slug, window } });
-    }
+    // --- stack activity ---
     /** Activity for the stack selected by the bearer stack key or session. */
     stackActivity(window = "24h") {
         return this.request("GET", "/v1/stack/activity", { query: { window } });
     }
 }
-export class GraphNamespace {
-    client;
-    facts;
-    constructor(client) {
-        this.client = client;
-        this.facts = new FactsNamespace(client);
-    }
-    branch(name) {
-        return new GraphNamespace(this.client.withScope({ branch: name }));
-    }
-    create() {
-        return this.client.createGraph();
-    }
-    delete(opts) {
-        return this.client.deleteGraph(opts);
-    }
-    /** Retract edges/entities from the scoped graph. See {@link LbbClient.retract}. */
-    retract(body, opts = {}) {
-        return this.client.retract(body, opts);
-    }
-}
-export class FactsNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    create(body, opts = {}) {
-        return this.client.request("POST", "/v1/graph/commit", {
-            body,
-            idempotencyKey: opts.idempotencyKey ?? this.client.idempotencyKey("facts.create"),
-        });
-    }
-    /** Bulk-load a dataset as NDJSON. See {@link LbbClient.import}. */
-    import(lines, opts = {}) {
-        return this.client.import(lines, opts);
-    }
-    /**
-     * 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, opts = {}) {
-        return this.client.importRdf(ntriples, opts);
-    }
-}
-export class SearchNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    hybrid(input, opts = {}) {
-        if (typeof input !== "string") {
-            return this.client.request("POST", "/v1/graph/search", { body: input });
-        }
-        return this.client.request("GET", "/v1/search", {
-            query: {
-                query: input,
-                top_k: opts.topK,
-                source: opts.source,
-                consistency: opts.consistency,
-                lexical: opts.lexical,
-                bm25: opts.bm25,
-                vector: opts.vector,
-                targets: opts.targets?.join(","),
-                profile: opts.profile,
-                log_impression: opts.logImpression,
-            },
-        });
-    }
-    multi(body) {
-        return this.client.multiSearch(body);
-    }
-    feedback(body, opts = {}) {
-        return this.client.searchFeedback(body, opts);
-    }
-    feedbackExport() {
-        return this.client.searchFeedbackExport();
-    }
-    fullText(body) {
-        return this.client.fullTextSearch(body);
-    }
-    vector(body) {
-        return this.client.embeddingSearch(body);
-    }
-}
-export class SchemaNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    /** Active graph schema bundle: ontology plus activated SHACL shapes. */
-    view(opts = {}) {
-        return this.client.request("GET", "/v1/schema", {
-            query: { audit: opts.audit || undefined },
-        });
-    }
-    /** Preview a proposed RDF/SHACL schema bundle and audit current data. */
-    preview(body) {
-        return this.client.request("POST", "/v1/schema/preview", { body });
-    }
-    /** Activate a previewed SHACL schema bundle for this graph branch. */
-    publish(body) {
-        return this.client.request("POST", "/v1/schema/publish", { body });
-    }
-    /** Audit current data against the active SHACL schema bundle. */
-    audit() {
-        return this.client.request("POST", "/v1/schema/audit");
-    }
-}
-export class IndexNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    run(opts = {}) {
-        const background = opts.background ?? (opts.wait === false ? true : undefined);
-        return this.client.request("POST", "/v1/index/run", {
-            query: { background },
-            body: opts.body,
-        });
-    }
-    build() {
-        return this.client.indexBuild();
-    }
-    delta() {
-        return this.client.indexDelta();
-    }
-    gc(opts = {}) {
-        return this.client.indexGc(opts);
-    }
-}
-export class EntityNamespace {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * 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 = {}) {
-        const csv = (v) => Array.isArray(v) ? v.join(",") : v;
-        return this.client.request("GET", "/v1/graph/entities", {
-            query: {
-                type: opts.type,
-                limit: opts.limit,
-                cursor: opts.cursor,
-                offset: opts.offset,
-                q: opts.query,
-                fields: csv(opts.fields),
-                ids: csv(opts.ids),
-            },
-        });
-    }
-    get(opts) {
-        return this.client.entityMetadata(opts);
-    }
-    detail(opts) {
-        return this.client.entityDetail(opts);
-    }
-    /**
-     * 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) {
-        const defaultVar = firstPatternVariable(opts.patterns);
-        const where = Array.isArray(opts.where) ? opts.where : [opts.where];
-        return this.client.sparql({
-            patterns: opts.patterns,
-            filters: [...(opts.filters ?? []), ...where.map((filter) => attributeFilter(filter, defaultVar))],
-            select: opts.select,
-            limit: opts.limit,
-            offset: opts.offset,
-            as_of_valid_time: opts.asOfValidTime,
-            as_of_commit_seq: opts.asOfCommitSeq,
-            order_by: opts.orderBy,
-            reason: opts.reason,
-            max_solutions: opts.maxSolutions,
-            max_object_reads: opts.maxObjectReads,
-            max_fetched_bytes: opts.maxFetchedBytes,
-        });
-    }
-}