hippo-memory 2.0.0 → 2.1.0

package/dist/search/multihop.js

@@ -3,14 +3,7 @@ import { fitBudget } from './finalize.js';
 import { search } from './bm25-search.js';
 import { DEFAULT_RECALL_BUDGET } from '../core/search-types.js';
 const PASS1_TOP_K = 10;
-export function multihopSearch(query, entries, options = {}) {
-    const budget = options.budget ?? DEFAULT_RECALL_BUDGET;
-    // Pass 1 searches wide to find entities, so each return fits the caller's budget, as search() does.
-    const fit = (ordered) => fitBudget(ordered, budget, options.minResults ?? 1, options.cost);
-    const pass1 = search(query, entries, { ...options, budget: budget * 2 });
-    const topK = pass1.slice(0, PASS1_TOP_K);
-    if (topK.length === 0)
-        return [];
+function newEntitiesOf(topK, query) {
     const entityTags = new Set();
     for (const r of topK) {
         for (const tag of r.entry.tags) {
@@ -20,9 +13,17 @@ export function multihopSearch(query, entries, options = {}) {
         }
     }
     const queryLower = query.toLowerCase();
-    const newEntities = [...entityTags]
-        .map((t) => t.split(':')[1])
-        .filter((e) => !queryLower.includes(e.toLowerCase()));
+    return [...entityTags].map((t) => t.split(':')[1]).filter((e) => !queryLower.includes(e.toLowerCase()));
+}
+export function multihopSearch(query, entries, options = {}) {
+    const budget = options.budget ?? DEFAULT_RECALL_BUDGET;
+    // Pass 1 searches wide to find entities, so each return fits the caller's budget, as search() does.
+    const fit = (ordered) => fitBudget(ordered, budget, options.minResults ?? 1, options.cost);
+    const pass1 = search(query, entries, { ...options, budget: budget * 2 });
+    const topK = pass1.slice(0, PASS1_TOP_K);
+    if (topK.length === 0)
+        return [];
+    const newEntities = newEntitiesOf(topK, query);
     if (newEntities.length === 0)
         return fit(pass1);
     const followUpQuery = newEntities.join(' ') + ' ' + query;
@@ -34,8 +35,8 @@ export function multihopSearch(query, entries, options = {}) {
             merged.set(r.entry.id, r);
         }
     }
-    // PLAIN stable score sort on purpose: pass1/pass2 inputs are already deterministically ordered (search() carries the content tail),
-    // stability inherits that, and ties keep pass-1 results ahead of pass-2 follow-ups.
+    // PLAIN stable score sort on purpose: pass1/pass2 inputs are already deterministically ordered (search() carries the
+    // content tail), stability inherits that, and ties keep pass-1 results ahead of pass-2 follow-ups.
     return fit([...merged.values()].sort((a, b) => compareScoresDesc(a.score, b.score)));
 }
 //# sourceMappingURL=multihop.js.map

package/dist/search/path-context.d.ts

@@ -1,11 +1,18 @@
-/** Extracts meaningful path segments from a directory as tags like ['path:src', 'path:my-project']; filters noise (node_modules, .git, Users, home dirs,
+/**
+ * Extracts meaningful path segments from a directory as tags like ['path:src', 'path:my-project']; filters noise
+ * (node_modules, .git, Users, home dirs,
  * drive letters). */
 export declare function extractPathTags(dirPath: string): string[];
 /** Path overlap score in 0..1 (1 = perfect match), normalized by the MORE SPECIFIC side (the larger tag set),
- * so a bare/generic path tag cannot score 1.0 against a deeply nested cwd just because its tiny tag set is contained in the query's. */
+ * so a bare/generic path tag cannot score 1.0 against a deeply nested cwd just because its tiny tag set is contained in
+ * the query's.
+ */
 export declare function pathOverlapScore(memoryPathTags: string[], currentPathTags: string[]): number;
 /** Weight applied to path overlap score when computing the recall boost multiplier. */
 export declare const PATH_BOOST_WEIGHT = 0.3;
-/** Multiplier (1.0..1.3) applied to a composite recall score for path locality; filters the memory's tags to path:* itself so call sites cannot drift. */
+/**
+ * Multiplier (1.0..1.3) applied to a composite recall score for path locality; filters the memory's tags to path:*
+ * itself so call sites cannot drift.
+ */
 export declare function pathBoostMultiplier(memoryTags: string[], currentPathTags: string[]): number;
 //# sourceMappingURL=path-context.d.ts.map

package/dist/search/path-context.js

@@ -1,6 +1,8 @@
 // Keeps the last meaningful segments, the most specific ones.
 const PATH_SEGMENTS_KEPT = 4;
-/** Extracts meaningful path segments from a directory as tags like ['path:src', 'path:my-project']; filters noise (node_modules, .git, Users, home dirs,
+/**
+ * Extracts meaningful path segments from a directory as tags like ['path:src', 'path:my-project']; filters noise
+ * (node_modules, .git, Users, home dirs,
  * drive letters). */
 export function extractPathTags(dirPath) {
     const normalized = dirPath.replace(/\\/g, '/');
@@ -17,7 +19,9 @@ export function extractPathTags(dirPath) {
         .map(s => `path:${s.toLowerCase()}`);
 }
 /** Path overlap score in 0..1 (1 = perfect match), normalized by the MORE SPECIFIC side (the larger tag set),
- * so a bare/generic path tag cannot score 1.0 against a deeply nested cwd just because its tiny tag set is contained in the query's. */
+ * so a bare/generic path tag cannot score 1.0 against a deeply nested cwd just because its tiny tag set is contained in
+ * the query's.
+ */
 export function pathOverlapScore(memoryPathTags, currentPathTags) {
     if (memoryPathTags.length === 0 || currentPathTags.length === 0)
         return 0;
@@ -29,7 +33,10 @@ export function pathOverlapScore(memoryPathTags, currentPathTags) {
 }
 /** Weight applied to path overlap score when computing the recall boost multiplier. */
 export const PATH_BOOST_WEIGHT = 0.3;
-/** Multiplier (1.0..1.3) applied to a composite recall score for path locality; filters the memory's tags to path:* itself so call sites cannot drift. */
+/**
+ * Multiplier (1.0..1.3) applied to a composite recall score for path locality; filters the memory's tags to path:*
+ * itself so call sites cannot drift.
+ */
 export function pathBoostMultiplier(memoryTags, currentPathTags) {
     const memPathTags = memoryTags.filter(t => t.startsWith('path:'));
     return 1.0 + pathOverlapScore(memPathTags, currentPathTags) * PATH_BOOST_WEIGHT;

package/dist/search/physics-search.d.ts

@@ -14,7 +14,8 @@ export interface PhysicsSearchOptions {
     cost?: ResultCost;
     /** Active scope for scope-boost scoring. Auto-detected if not provided. */
     scope?: string | null;
-    /** Include superseded memories; must reach the inner hybrid filter or `recall --include-superseded` rows drop out here. */
+    /** Include superseded memories; must reach the inner hybrid filter or `recall --include-superseded` rows drop out
+     * here. */
     includeSuperseded?: boolean;
     /** Bi-temporal filter: memories current at this ISO date string, ranked by hybridSearch. */
     asOf?: string;
@@ -27,9 +28,13 @@ export interface PhysicsSearchOptions {
     /** Where vectors and particles are read; hippo.db under `hippoRoot` when unset. */
     store?: HippoStore;
 }
-/** Scores memories by gravity, momentum and cluster amplification; rows without physics state rank through hybridSearch.
- *  Reads hippo.db under `hippoRoot` when no store is passed. */
+/** Scores memories by gravity, momentum and cluster amplification; rows without physics state rank through
+ * hybridSearch.
+ *  Reads hippo.db under `hippoRoot` when no store is passed.
+ * @deprecated The root export is removed in 3.0. Set `physics.enabled` to 'auto' or true in config to rank by
+ * physics. */
 export declare function physicsSearch(query: string, entries: MemoryEntry[], options?: PhysicsSearchOptions): Promise<SearchResult[]>;
-/** physicsSearch on the store the caller names, so a caller holding its request's store never falls back to hippo.db. */
+/** physicsSearch on the store the caller names, so a caller holding its request's store never falls back to
+ * hippo.db. */
 export declare function physicsSearchIn(source: VectorSource, query: string, entries: MemoryEntry[], options?: PhysicsSearchOptions): Promise<SearchResult[]>;
 //# sourceMappingURL=physics-search.d.ts.map

package/dist/search/physics-search.js

@@ -8,21 +8,25 @@ import { physicsScore as computePhysicsScores, computeMass } from '../core/physi
 import { DEFAULT_PHYSICS_CONFIG } from '../core/physics-config.js';
 import { rethrowIfSqliteBlocked } from '../util/sqlite-blocked.js';
 import { compareScoredResults } from '../core/compare.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { churnStaleFactor, summaryMultipliers, summaryScoring } from './boosts.js';
 import { addDagFields, ageInDays } from './breakdown.js';
 import { fitBudget } from './finalize.js';
 import { hybridSearch, vectorSourceOf } from './hybrid.js';
 import { currentEntries } from './as-of.js';
 import { embedQueryBy, requireVectorReads, startQueryEmbedDeadline, vectorCandidatesOutside, } from './vector.js';
-import { DEFAULT_RECALL_BUDGET } from '../core/search-types.js';
-/** Scores memories by gravity, momentum and cluster amplification; rows without physics state rank through hybridSearch.
- *  Reads hippo.db under `hippoRoot` when no store is passed. */
+import { DEFAULT_RECALL_BUDGET, } from '../core/search-types.js';
+/** Scores memories by gravity, momentum and cluster amplification; rows without physics state rank through
+ * hybridSearch.
+ *  Reads hippo.db under `hippoRoot` when no store is passed.
+ * @deprecated The root export is removed in 3.0. Set `physics.enabled` to 'auto' or true in config to rank by
+ * physics. */
 export async function physicsSearch(query, entries, options = {}) {
     const source = entries.length > 0 ? vectorSourceOf(options) : undefined;
     return source ? physicsSearchIn(source, query, entries, options) : [];
 }
-/** physicsSearch on the store the caller names, so a caller holding its request's store never falls back to hippo.db. */
+/** physicsSearch on the store the caller names, so a caller holding its request's store never falls back to
+ * hippo.db. */
 export async function physicsSearchIn(source, query, entries, options = {}) {
     const now = options.now ?? evalNow(); // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
     const explain = options.explain ?? false;
@@ -49,7 +53,13 @@ export async function physicsSearchIn(source, query, entries, options = {}) {
     const config = options.physicsConfig ?? DEFAULT_PHYSICS_CONFIG;
     const physicsResults = scorePhysicsPool(pools, queryVector, config, scoring);
     const classicResults = pools.classic.length > 0
-        ? await hybridSearch(query, pools.classic, { ...hybrid, queryEmbedDeadline, vectorCandidates: undefined, budget: Infinity, explain })
+        ? await hybridSearch(query, pools.classic, {
+            ...hybrid,
+            queryEmbedDeadline,
+            vectorCandidates: undefined,
+            budget: Infinity,
+            explain,
+        })
         : [];
     const merged = mergeScorePools(physicsResults, classicResults);
     merged.sort(compareScoredResults);
@@ -64,14 +74,15 @@ async function physicsQueryVector(query, root, store, deadline, given) {
         const provider = resolveEmbeddingProvider(root);
         if (!provider.isAvailable())
             return null;
-        if (indexNeedsRebuild(indexedModel(await requireVectorReads(store).embeddingIndexState()), provider.id))
+        if (indexNeedsRebuild(indexedModel(await requireVectorReads(store).embeddingIndexState()), provider.id)) {
             return null;
+        }
         const vec = await embedQueryBy(deadline, provider, query);
         return vec && vec.length > 0 ? vec : null;
     }
     catch (err) {
         rethrowIfSqliteBlocked(err);
-        log.debug(`physics search: query embed failed, using hybrid: ${errorMessage(err)}`);
+        log.warn(`physics search: query embed failed, using hybrid: ${errorMessage(err)}`, errorFields(err));
         return null;
     }
 }
@@ -83,7 +94,7 @@ async function withVectorCandidates(reads, entries, queryVector, spec) {
     }
     catch (err) {
         rethrowIfSqliteBlocked(err);
-        log.warn(`physics search ranked the lexical pool only; the vector lookup failed: ${errorMessage(err)}`);
+        log.warn(`physics search ranked the lexical pool only; the vector lookup failed: ${errorMessage(err)}`, errorFields(err));
         return entries;
     }
 }
@@ -94,7 +105,7 @@ async function loadCandidateParticles(reads, pool) {
     }
     catch (err) {
         rethrowIfSqliteBlocked(err);
-        log.debug(`physics search: state load failed, using hybrid: ${errorMessage(err)}`);
+        log.warn(`physics search: state load failed, using hybrid: ${errorMessage(err)}`, errorFields(err));
         return null;
     }
 }
@@ -111,9 +122,13 @@ function splitByParticle(pool, physicsMap, queryVector, now) {
             continue;
         }
         pools.entries.push(entry);
-        // EVAL-ONLY ablation (see ablation.ts): persisted masses bake in recall history twice, so the flag recomputes mass live.
+        // EVAL-ONLY ablation (see ablation.ts): persisted masses bake in recall history twice, so the flag recomputes mass
+        // live.
         pools.particles.push(isRecallBoostAblated()
-            ? { ...particle, mass: computeMass(calculateStrength(entry, now, { ablation: strengthAblation() }), entry.retrieval_count) }
+            ? {
+                ...particle,
+                mass: computeMass(calculateStrength(entry, now, { ablation: strengthAblation() }), entry.retrieval_count),
+            }
             : particle);
     }
     return pools;
@@ -136,7 +151,13 @@ function scorePhysicsPool(pools, queryVector, config, scoring) {
         const finalScore = s.finalScore * summary.deboost * summary.freshness * churnStaleMultiplier;
         if (finalScore <= 0)
             continue;
-        const result = { entry, score: finalScore, bm25: 0, cosine: s.baseScore, tokens: estimateTokens(entry.content) };
+        const result = {
+            entry,
+            score: finalScore,
+            bm25: 0,
+            cosine: s.baseScore,
+            tokens: estimateTokens(entry.content),
+        };
         if (scoring.explain) {
             result.breakdown = addDagFields(physicsBreakdown(entry, s.baseScore, finalScore, churnStaleMultiplier, scoring.now), entry, summary.deboost, summary.freshness);
         }
@@ -170,6 +191,9 @@ function mergeScorePools(poolA, poolB) {
     const unpenalised = (r) => r.score / churnStaleFactor(r.entry);
     const maxA = poolA.reduce((m, r) => Math.max(m, unpenalised(r)), 1e-9);
     const maxB = poolB.reduce((m, r) => Math.max(m, unpenalised(r)), 1e-9);
-    return [...poolA.map((r) => ({ ...r, score: r.score / maxA })), ...poolB.map((r) => ({ ...r, score: r.score / maxB }))];
+    return [
+        ...poolA.map((r) => ({ ...r, score: r.score / maxA })),
+        ...poolB.map((r) => ({ ...r, score: r.score / maxB })),
+    ];
 }
 //# sourceMappingURL=physics-search.js.map

package/dist/search/rerank.d.ts

@@ -1,7 +1,8 @@
 import type { RerankerFn, RerankerOptions } from '../rerankers/types.js';
 import type { SearchResult } from '../core/search-types.js';
 /** MMR: repeatedly picks the candidate maximising lambda * relevance - (1 - lambda) * max(cos(cand, picked)).
- *  Input must be sorted by relevance; strict `>` keeps ties first-wins, so a deterministic input stays deterministic. */
+ * Input must be sorted by relevance; strict `>` keeps ties first-wins, so a deterministic input stays deterministic.
+ */
 export declare function mmrRerank(scored: SearchResult[], embeddingIndex: Record<string, ArrayLike<number>>, lambda: number, explain: boolean): SearchResult[];
 /** MMR over the top window only; the tail keeps its relevance order. */
 export declare function applyMmrWindow(scored: SearchResult[], embeddingIndex: Record<string, ArrayLike<number>>, lambda: number, explain: boolean): SearchResult[];

package/dist/search/rerank.js

@@ -3,7 +3,8 @@ const DEFAULT_RERANK_TOP_K = 50;
 // MMR is O(K^2) cosine ops; candidates below this window never survive budget filtering anyway.
 const MMR_CANDIDATE_CAP = 100;
 /** MMR: repeatedly picks the candidate maximising lambda * relevance - (1 - lambda) * max(cos(cand, picked)).
- *  Input must be sorted by relevance; strict `>` keeps ties first-wins, so a deterministic input stays deterministic. */
+ * Input must be sorted by relevance; strict `>` keeps ties first-wins, so a deterministic input stays deterministic.
+ */
 export function mmrRerank(scored, embeddingIndex, lambda, explain) {
     if (scored.length === 0)
         return scored;

package/dist/search/rrf.d.ts

@@ -1,15 +1,24 @@
-/** Reciprocal Rank Fusion (Cormack, Clarke and Buettcher 2009): fuses N ranked lists by summing weighted 1/(k + rank) per candidate. K is the standard 60,
- * the value hybridSearch already uses; do NOT tune it without a cross-corpus eval. Generic over the id type (hybridSearch uses number, the LongMemEval
- * benchmark string). Behaviour MUST stay byte-identical to the inline hybridSearch code it replaced; tests/rrf.test.ts is the contract. */
+/**
+ * Reciprocal Rank Fusion (Cormack, Clarke and Buettcher 2009): fuses N ranked lists by summing weighted 1/(k + rank)
+ * per candidate. K is the standard 60,
+ * the value hybridSearch already uses; do NOT tune it without a cross-corpus eval. Generic over the id type
+ * (hybridSearch uses number, the LongMemEval
+ * benchmark string). Behaviour MUST stay byte-identical to the inline hybridSearch code it replaced; tests/rrf.test.ts
+ * is the contract.
+ */
 export declare const RRF_K = 60;
 export interface RrfFuseOptions {
     /** Smoothing constant. Default RRF_K = 60. */
     k?: number;
-    /** Rank assigned to candidates absent from a list; default `max(rankedLists.map(l => l.length)) + 1`, the convention hybridSearch used (`entries.length +
+    /**
+     * Rank assigned to candidates absent from a list; default `max(rankedLists.map(l => l.length)) + 1`, the convention
+     * hybridSearch used (`entries.length +
      * 1`). */
     absentRank?: number;
 }
-/** Fuses N ranked lists (each in descending-score order; index 0 is rank 1) into a Map of candidate id -> RRF score; sort by value descending for the fused
+/**
+ * Fuses N ranked lists (each in descending-score order; index 0 is rank 1) into a Map of candidate id -> RRF score;
+ * sort by value descending for the fused
  * order. `weights` has one entry per list and is summed without normalisation; `options` overrides k and absentRank. */
 export declare function rrfFuse<T>(rankedLists: ReadonlyArray<ReadonlyArray<T>>, weights: ReadonlyArray<number>, options?: RrfFuseOptions): Map<T, number>;
 //# sourceMappingURL=rrf.d.ts.map

package/dist/search/rrf.js

@@ -1,8 +1,15 @@
-/** Reciprocal Rank Fusion (Cormack, Clarke and Buettcher 2009): fuses N ranked lists by summing weighted 1/(k + rank) per candidate. K is the standard 60,
- * the value hybridSearch already uses; do NOT tune it without a cross-corpus eval. Generic over the id type (hybridSearch uses number, the LongMemEval
- * benchmark string). Behaviour MUST stay byte-identical to the inline hybridSearch code it replaced; tests/rrf.test.ts is the contract. */
+/**
+ * Reciprocal Rank Fusion (Cormack, Clarke and Buettcher 2009): fuses N ranked lists by summing weighted 1/(k + rank)
+ * per candidate. K is the standard 60,
+ * the value hybridSearch already uses; do NOT tune it without a cross-corpus eval. Generic over the id type
+ * (hybridSearch uses number, the LongMemEval
+ * benchmark string). Behaviour MUST stay byte-identical to the inline hybridSearch code it replaced; tests/rrf.test.ts
+ * is the contract.
+ */
 export const RRF_K = 60;
-/** Fuses N ranked lists (each in descending-score order; index 0 is rank 1) into a Map of candidate id -> RRF score; sort by value descending for the fused
+/**
+ * Fuses N ranked lists (each in descending-score order; index 0 is rank 1) into a Map of candidate id -> RRF score;
+ * sort by value descending for the fused
  * order. `weights` has one entry per list and is summed without normalisation; `options` overrides k and absentRank. */
 export function rrfFuse(rankedLists, weights, options) {
     if (rankedLists.length !== weights.length) {

package/dist/search/vector.d.ts

@@ -3,7 +3,10 @@ import type { VectorCandidateSpec } from '../store/search-rows.js';
 import { type EmbeddingProvider } from '../embeddings/provider.js';
 import { type HippoStore, type VectorReads } from '../store/index.js';
 import { type CurrentnessOptions } from './as-of.js';
-/** hybridSearch's vector arm: which rows it may add, plus the caller's JS admission rules (exact private regex, entry filters). */
+/**
+ * hybridSearch's vector arm: which rows it may add, plus the caller's JS admission rules (exact private regex, entry
+ * filters).
+ */
 export type HybridVectorCandidates = VectorCandidateSpec & {
     admit?: (entry: MemoryEntry) => boolean;
 };
@@ -27,7 +30,10 @@ export interface VectorArmOptions extends CurrentnessOptions {
 }
 /** One deadline for every query embedding a recall makes, so two stores or a physics fallback share the budget. */
 export declare function startQueryEmbedDeadline(): AbortSignal;
-/** The query's vector, or null when the provider outlasts `deadline`: an API call, or a local model still downloading. Any other failure throws. */
+/**
+ * The query's vector, or null when the provider outlasts `deadline`: an API call, or a local model still downloading.
+ * Any other failure throws.
+ */
 export declare function embedQueryBy(deadline: AbortSignal, provider: EmbeddingProvider, query: string): Promise<number[] | null>;
 /** The store's vector reads; a store without them answers 501, as any unported path does. */
 export declare function requireVectorReads(store: HippoStore): VectorReads;

package/dist/search/vector.js

@@ -10,7 +10,9 @@ import { redactSecretsStrict } from '../util/secret-detect.js';
 import { currentEntries } from './as-of.js';
 // Jev's default budget (rerankers/jev.ts): each is one off-box call that a recall waits on.
 const QUERY_EMBED_BUDGET_MS = 5_000;
-/** How long one recall waits for its query vector, retries included; HIPPO_QUERY_EMBED_TIMEOUT_MS overrides the default. */
+/**
+ * How long one recall waits for its query vector, retries included; HIPPO_QUERY_EMBED_TIMEOUT_MS overrides the default.
+ */
 function queryEmbedBudgetMs() {
     return envQueryEmbedTimeoutMs() ?? QUERY_EMBED_BUDGET_MS;
 }
@@ -18,7 +20,10 @@ function queryEmbedBudgetMs() {
 export function startQueryEmbedDeadline() {
     return AbortSignal.timeout(queryEmbedBudgetMs());
 }
-/** The query's vector, or null when the provider outlasts `deadline`: an API call, or a local model still downloading. Any other failure throws. */
+/**
+ * The query's vector, or null when the provider outlasts `deadline`: an API call, or a local model still downloading.
+ * Any other failure throws.
+ */
 export async function embedQueryBy(deadline, provider, query) {
     try {
         return (await provider.embed([query], 'query', { signal: deadline }))[0] ?? [];
@@ -29,7 +34,8 @@ export async function embedQueryBy(deadline, provider, query) {
         throw err;
     }
 }
-// Search runs on every hook prompt, so one line per reason per process says why vectors went unused without flooding stderr.
+// Search runs on every hook prompt, so one line per reason per process says why vectors went unused without flooding
+// stderr.
 function warnBm25Fallback(reason, detail) {
     log.once(`search.bm25-fallback.${reason}`, 'warn', `hybrid search fell back to BM25 only: ${redactSecretsStrict(detail)}`);
 }

package/dist/server/auth.d.ts

@@ -1,12 +1,14 @@
 import type { IncomingMessage } from 'node:http';
-import { type Context } from '../api/index.js';
+import { type Context, type StoreContext } from '../api/index.js';
 import type { ResolvedServeOpts } from './types.js';
-/** Recognises loopback remote addresses, including the IPv6-mapped '::ffff:127.0.0.1' Node reports on dual-stack sockets; anything else is remote. */
-export declare function isLoopback(remoteAddress: string | undefined): boolean;
-/** True only for a request made on this machine by its own user: a proxy and a browser page are loopback too, so the socket alone proves nothing. */
+import { isLoopbackAddress } from '../util/net.js';
+/** Kept under its old name because src/server.ts publishes it. */
+export declare const isLoopback: typeof isLoopbackAddress;
+/** True only for a request made on this machine by its own user: a proxy and a browser page are loopback too, so the
+ * socket alone proves nothing. */
 export declare function isLocalCaller(req: IncomingMessage): boolean;
-/** Reads the Authorization header case-insensitively (name and RFC 6750 'Bearer' scheme): { kind: 'absent' }, { kind: 'malformed' } (set but not 'Bearer
- * <token>'), or { kind: 'bearer', token } for a non-empty token. */
+/** Reads the Authorization header case-insensitively (name and RFC 6750 'Bearer' scheme): { kind: 'absent' },
+ * { kind: 'malformed' } (set but not 'Bearer <token>'), or { kind: 'bearer', token } for a non-empty token. */
 type AuthHeader = {
     kind: 'absent';
 } | {
@@ -21,15 +23,17 @@ type AuthOpts = Pick<ResolvedServeOpts, 'hippoRoot' | 'authResolver' | 'authReso
 export declare function isReservedActor(subject: string): boolean;
 /** Key cap for every serve() bucket, shared by the warn map so it never tracks more callers than the buckets do. */
 export declare const LIMITER_MAX_KEYS = 10000;
-/** Builds a per-request Context from the Authorization header and remote address; throws HttpError(401) for invalid or missing credentials.
- * Reads the store only for an API-key-shaped Bearer (or any Bearer when no auth resolver is registered), so keyless local requests stay cheap. */
-export declare function buildContextWithAuth(req: IncomingMessage, opts: AuthOpts): Promise<Context>;
-/** The auth check again, uncharged, for a handler that authenticated with requireAuth before a slow body read and must re-check right before it acts. */
-export declare function recheckContextWithAuth(req: IncomingMessage, opts: AuthOpts): Promise<Context>;
-/** Auth check for routes that need no tenant Context (e.g. the MCP transport, which resolves its own root): throws HttpError 401 like buildContextWithAuth.
- * A keyless local request passes only under HIPPO_ALLOW_KEYLESS_LOCAL=1. */
+/** Builds a per-request Context from the Authorization header and remote address; throws HttpError(401) on bad ones.
+ * Reads the store only for an API-key-shaped Bearer (or any Bearer with no resolver), so keyless calls stay cheap. */
+export declare function buildContextWithAuth(req: IncomingMessage, opts: AuthOpts): Promise<StoreContext>;
+/** The auth check again, uncharged, for a handler that authenticated with requireAuth before a slow body read and
+ * must re-check right before it acts. */
+export declare function recheckContextWithAuth(req: IncomingMessage, opts: AuthOpts): Promise<StoreContext>;
+/** Auth check for routes that need no tenant Context (e.g. the MCP transport, which resolves its own root): throws
+ * HttpError 401 like buildContextWithAuth. A keyless local request passes only under HIPPO_ALLOW_KEYLESS_LOCAL=1. */
 export declare function requireAuth(req: IncomingMessage, opts: AuthOpts): Promise<void>;
-/** Never rejects or charges a caller bucket: an outage (5xx) or a throttle (429) skips one tick; only a definite 4xx denial closes the stream. */
+/** Never rejects or charges a caller bucket: an outage (5xx) or a throttle (429) skips one tick; only a definite 4xx
+ * denial closes the stream. */
 export declare function heartbeatVerdict(req: IncomingMessage, opts: AuthOpts): Promise<'ok' | 'revoked' | 'unavailable'>;
 /** Gate for any action beyond the caller's own tenant: a tenant's admin, by key or resolver, is never a host admin. */
 export declare function assertCrossTenantAdmin(ctx: Context, what: string): void;