hippo-memory 1.43.3 → 1.45.0

package/dist/embedding-provider.js

@@ -4,7 +4,7 @@
  * The local `@huggingface/transformers` path stays the zero-DEPENDENCY DEFAULT. Opt-in
  * API providers (OpenAI / Voyage / Cohere) let a user bring a frontier embedder
  * (e.g. text-embedding-3-large) for frontier-class retrieval. They use the native
- * `fetch` global (Node >= 22.5, see package.json engines — NO new dependency) and
+ * `fetch` global (Node >= 22.16, see package.json engines; NO new dependency) and
  * read their key from a conventional env var. The provider is selected by
  * `config.embeddings.provider` (default `'local'`).
  *
@@ -31,6 +31,7 @@
  */
 import { getEmbedding, isEmbeddingAvailable, resolveEmbeddingModel, DEFAULT_EMBEDDING_MODEL, } from './embeddings.js';
 import { loadConfig } from './config.js';
+import { redactSecrets } from './secret-detect.js';
 export const API_PROVIDER_KINDS = ['openai', 'voyage', 'cohere'];
 function isApiProviderKind(x) {
     return x === 'openai' || x === 'voyage' || x === 'cohere';
@@ -188,7 +189,7 @@ class ApiEmbeddingProvider {
                     'content-type': 'application/json',
                     authorization: `Bearer ${key}`,
                 },
-                body: JSON.stringify(spec.buildBody(this.model, chunk, role)),
+                body: JSON.stringify(spec.buildBody(this.model, chunk.map(redactSecrets), role)),
                 signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
             });
         }

package/dist/embeddings.js

@@ -5,6 +5,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { randomUUID } from 'crypto';
 import { createRequire } from 'module';
 import { loadAllEntries } from './store.js';
 import { openHippoDb, closeHippoDb, getMeta, setMeta } from './db.js';
@@ -244,13 +245,13 @@ export function saveStoredEmbeddingModel(hippoRoot, model) {
         closeHippoDb(db);
     }
 }
-export function resolveIndexedEmbeddingModel(hippoRoot, index = loadEmbeddingIndex(hippoRoot)) {
+export function resolveIndexedEmbeddingModel(hippoRoot, index) {
     const stored = loadStoredEmbeddingModel(hippoRoot);
     if (stored)
         return stored;
-    return Object.keys(index).length > 0 ? DEFAULT_EMBEDDING_MODEL : null;
+    return Object.keys(index ?? loadEmbeddingIndex(hippoRoot)).length > 0 ? DEFAULT_EMBEDDING_MODEL : null;
 }
-export function embeddingModelRequiresReindex(hippoRoot, model, index = loadEmbeddingIndex(hippoRoot)) {
+export function embeddingModelRequiresReindex(hippoRoot, model, index) {
     const stored = resolveIndexedEmbeddingModel(hippoRoot, index);
     return stored !== null && stored !== embeddingIndexIdentity(model);
 }
@@ -374,16 +375,86 @@ export function saveEmbeddingIndex(hippoRoot, index) {
         throw err;
     }
 }
-// Mutex to serialize embedding writes and prevent read-modify-write races
+const EMBED_LOCK_FILE = 'embeddings.lock';
+const EMBED_LOCK_WAIT_MS = 10_000;
+const EMBED_LOCK_OWNER = `${process.pid}:${randomUUID()}`;
+// In-process mutex plus an O_EXCL "<pid>:<token>" lock file: our token is a lock we leaked; our PID with another token is a live worker thread, unless the lock predates this process (a reused PID).
 let _embedWriteLock = Promise.resolve();
-async function withEmbedLock(fn) {
+function embedLockHolderAlive(lockPath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(lockPath, 'utf8');
+    }
+    catch (err) {
+        return !(err instanceof Error && 'code' in err && err.code === 'ENOENT');
+    }
+    const mtimeMs = fs.statSync(lockPath, { throwIfNoEntry: false })?.mtimeMs ?? 0;
+    const pid = Number(raw.split(':')[0]);
+    // An empty lock is a holder between create and write; after 5 s it is a crashed one.
+    if (!Number.isInteger(pid) || pid <= 0)
+        return Date.now() - mtimeMs < 5_000;
+    if (raw === EMBED_LOCK_OWNER)
+        return false;
+    if (pid === process.pid)
+        return mtimeMs >= Date.now() - process.uptime() * 1000;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err instanceof Error && 'code' in err && err.code === 'EPERM';
+    }
+}
+// After the double-break race below the file can be another writer's lock, so remove only our own.
+function releaseEmbedFileLock(lockPath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(lockPath, 'utf8');
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT')
+            return;
+        throw err;
+    }
+    if (raw === EMBED_LOCK_OWNER)
+        fs.rmSync(lockPath, { force: true });
+}
+async function acquireEmbedFileLock(hippoRoot) {
+    const lockPath = path.join(hippoRoot, EMBED_LOCK_FILE);
+    const deadline = Date.now() + EMBED_LOCK_WAIT_MS;
+    for (;;) {
+        try {
+            fs.writeFileSync(lockPath, EMBED_LOCK_OWNER, { flag: 'wx' });
+            return () => releaseEmbedFileLock(lockPath);
+        }
+        catch (err) {
+            if (!(err instanceof Error && 'code' in err && err.code === 'EEXIST'))
+                throw err;
+        }
+        // SHORTCUT: two waiters can both break one dead holder's lock; a vector lost that way is backfilled by the next `hippo embed`.
+        if (!embedLockHolderAlive(lockPath)) {
+            fs.rmSync(lockPath, { force: true });
+            continue;
+        }
+        if (Date.now() >= deadline)
+            throw new Error(`embeddings.json is busy: another hippo process holds ${lockPath}`);
+        await new Promise((r) => setTimeout(r, 50));
+    }
+}
+async function withEmbedLock(hippoRoot, fn) {
     let resolve;
     const next = new Promise(r => { resolve = r; });
     const prev = _embedWriteLock;
     _embedWriteLock = next;
     await prev;
     try {
-        return await fn();
+        const release = await acquireEmbedFileLock(hippoRoot);
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
     }
     finally {
         resolve();
@@ -396,7 +467,7 @@ export async function embedMemory(hippoRoot, entry, model) {
     const provider = resolveEmbeddingProvider(hippoRoot, { model });
     if (!provider.isAvailable())
         return;
-    return withEmbedLock(async () => {
+    return withEmbedLock(hippoRoot, async () => {
         // embedMemory is best-effort: an embedding failure (API down / bad key / 5xx)
         // must not reject the caller's write — `getEmbedding` historically swallowed
         // failures and returned []. The explicit `hippo embed` / `embedAll` path is
@@ -445,6 +516,8 @@ export async function embedMemory(hippoRoot, entry, model) {
         catch {
             // Provider failure (API down / bad key). Best-effort: leave the index as-is.
         }
+    }).catch((err) => {
+        console.error(`hippo: skipped embedding ${entry.id} (${err instanceof Error ? err.message : String(err)}); run 'hippo embed' to backfill`);
     });
 }
 /**
@@ -468,7 +541,7 @@ export async function embedAll(hippoRoot, model) {
         }
         return 0;
     }
-    return withEmbedLock(async () => {
+    return withEmbedLock(hippoRoot, async () => {
         const identity = provider.id;
         // L9: host-wide by design. embedAll backfills vectors for all tenants'
         // entries into the per-host embedding index. Per-tenant filtering would

package/dist/extract.d.ts

@@ -8,6 +8,8 @@ export interface ExtractOptions {
     apiKey: string;
     model?: string;
     fetcher?: typeof fetch;
+    /** Told why a call produced nothing, so callers can surface it instead of guessing. */
+    onError?: (msg: string) => void;
 }
 export declare function extractFacts(text: string, opts: ExtractOptions): Promise<ExtractedFact[]>;
 export declare function storeExtractedFacts(hippoRoot: string, source: MemoryEntry, facts: ExtractedFact[]): MemoryEntry[];

package/dist/extract.js

@@ -1,6 +1,7 @@
 import { Layer, createMemory } from './memory.js';
 import { writeEntry } from './store.js';
 import { RejectedValueError } from './rejection.js';
+import { redactSecrets } from './secret-detect.js';
 function isJsonString(value) {
     return typeof value === 'string';
 }
@@ -31,15 +32,18 @@ export async function extractFacts(text, opts) {
             body: JSON.stringify({
                 model,
                 max_tokens: 1200,
-                messages: [{ role: 'user', content: EXTRACTION_PROMPT + text }],
+                messages: [{ role: 'user', content: EXTRACTION_PROMPT + redactSecrets(text) }],
             }),
         });
     }
-    catch {
+    catch (err) {
+        opts.onError?.(`request failed: ${err instanceof Error ? err.message : String(err)}`);
         return [];
     }
-    if (!res.ok)
+    if (!res.ok) {
+        opts.onError?.(`HTTP ${res.status}`);
         return [];
+    }
     try {
         const data = await res.json();
         const raw = data.content?.[0]?.text?.trim() ?? '';
@@ -69,7 +73,8 @@ export async function extractFacts(text, opts) {
         }
         return facts;
     }
-    catch {
+    catch (err) {
+        opts.onError?.(`unparseable response: ${err instanceof Error ? err.message : String(err)}`);
         return [];
     }
 }

package/dist/goals.js

@@ -101,7 +101,10 @@ export function pushGoalWithDb(db, opts) {
         db.exec('COMMIT');
     }
     catch (err) {
-        db.exec('ROLLBACK');
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* already rolled back; keep the original error */ }
         throw err;
     }
     return {
@@ -345,7 +348,10 @@ export function completeGoal(hippoRoot, goalId, opts) {
             db.exec('COMMIT');
         }
         catch (err) {
-            db.exec('ROLLBACK');
+            try {
+                db.exec('ROLLBACK');
+            }
+            catch { /* already rolled back; keep the original error */ }
             throw err;
         }
     }
@@ -379,7 +385,10 @@ export function resumeGoal(hippoRoot, goalId) {
             db.exec('COMMIT');
         }
         catch (err) {
-            db.exec('ROLLBACK');
+            try {
+                db.exec('ROLLBACK');
+            }
+            catch { /* already rolled back; keep the original error */ }
             throw err;
         }
     }

package/dist/mcp/server.js

@@ -10,9 +10,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createMemory, Layer, calculateStrength, } from '../memory.js';
-import { hybridSearch, physicsSearch, markRetrieved } from '../search.js';
-import { isRecallBoostAblated, evalNow } from '../ablation.js';
-import { loadAllEntries, writeEntry, readEntry, loadFreshActiveTaskSnapshot, listMemoryConflicts, resolveConflict, RECALL_DEFAULT_DENY_SCOPES } from '../store.js';
+import { hybridSearch, physicsSearch } from '../search.js';
+import { evalNow } from '../ablation.js';
+import { loadAllEntries, writeEntry, strengthenRetrieved, readEntry, loadFreshActiveTaskSnapshot, listMemoryConflicts, resolveConflict, RECALL_DEFAULT_DENY_SCOPES, countCreatedSinceLastSleep } from '../store.js';
 import { shareMemory, listPeers, getGlobalRoot } from '../shared.js';
 import { consolidate } from '../consolidate.js';
 import { execSync } from 'child_process';
@@ -359,6 +359,7 @@ const TOOLS = [
 // `${tenantId}:default` if a McpContext is constructed in tests without a
 // pid-bound transport.
 const lastRecalledIds = new Map();
+const autoSleepInFlight = new Set();
 function resolveClientKey(ctx) {
     if (ctx?.clientKey)
         return ctx.clientKey;
@@ -527,15 +528,9 @@ async function executeTool(name, args, ctx) {
                     closeHippoDb(dbForBoost);
                 }
             }
-            // Mark retrieved and persist
-            const retrieved = markRetrieved(results.map((r) => r.entry));
-            // EVAL-ONLY ablation (see ablation.ts): skip persistence under the recall
-            // flag; ids below stay populated for outcome attribution.
-            if (!isRecallBoostAblated()) {
-                for (const entry of retrieved)
-                    writeEntry(hippoRoot, entry, { actor: ctx?.actor ?? 'mcp' });
-            }
-            lastRecalledIds.set(resolveClientKey(ctx), retrieved.map((e) => e.id));
+            const retrievedIds = results.map((r) => r.entry.id);
+            strengthenRetrieved(hippoRoot, retrievedIds);
+            lastRecalledIds.set(resolveClientKey(ctx), retrievedIds);
             // v0.33 / J1 — MCP per-pipeline anchoring detector. UNLIKE J3.2's
             // planningFallacyHint (which is pipeline-invariant because it
             // depends only on queryText + predictions table state), the
@@ -902,22 +897,17 @@ async function executeTool(name, args, ctx) {
                 tags,
             });
             const entry = readEntry(hippoRoot, result.id, tenantId);
-            // Auto-sleep check
-            if (config.autoSleep.enabled) {
-                const allEntries = loadAllEntries(hippoRoot, tenantId);
-                const recentCount = allEntries.filter((e) => {
-                    const age = (Date.now() - new Date(e.created).getTime()) / (1000 * 60 * 60);
-                    return age < 24; // created in last 24 hours
-                }).length;
-                if (recentCount >= config.autoSleep.threshold) {
-                    // Fire-and-forget by design (never block the remember response), but
-                    // an unhandled rejection here can kill the MCP server process — any
-                    // consolidate error (DB contention, or the memoryValue fail-loud
-                    // throw) must land as a logged line, not a crash.
-                    consolidate(hippoRoot).catch((err) => {
-                        console.error(`auto-sleep consolidate failed: ${err instanceof Error ? err.message : err}`);
-                    });
-                }
+            // Auto-sleep: one run per store at a time, triggered by what arrived since the last one.
+            if (config.autoSleep.enabled &&
+                !autoSleepInFlight.has(hippoRoot) &&
+                countCreatedSinceLastSleep(hippoRoot, tenantId) >= config.autoSleep.threshold) {
+                autoSleepInFlight.add(hippoRoot);
+                // Fire-and-forget (never block the response); an unhandled rejection would kill the server, so log it.
+                consolidate(hippoRoot)
+                    .catch((err) => {
+                    console.error(`auto-sleep consolidate failed (tenant ${tenantId}): ${err instanceof Error ? err.message : err}`);
+                })
+                    .finally(() => autoSleepInFlight.delete(hippoRoot));
             }
             const halfLife = entry?.half_life_days ?? config.defaultHalfLifeDays;
             const tagStr = entry?.tags.join(', ') || tags.join(', ') || 'none';
@@ -1000,14 +990,9 @@ async function executeTool(name, args, ctx) {
             const results = usePhysicsCtx
                 ? await physicsSearch(query, entries, { budget, hippoRoot, physicsConfig: config.physics })
                 : await hybridSearch(query, entries, { budget, hippoRoot });
-            const retrieved = markRetrieved(results.map((r) => r.entry));
-            // EVAL-ONLY ablation (see ablation.ts): skip persistence under the recall
-            // flag; ids below stay populated for outcome attribution.
-            if (!isRecallBoostAblated()) {
-                for (const entry of retrieved)
-                    writeEntry(hippoRoot, entry, { actor: ctx?.actor ?? 'mcp' });
-            }
-            lastRecalledIds.set(resolveClientKey(ctx), retrieved.map((e) => e.id));
+            const retrievedIds = results.map((r) => r.entry.id);
+            strengthenRetrieved(hippoRoot, retrievedIds);
+            lastRecalledIds.set(resolveClientKey(ctx), retrievedIds);
             // DF1 (docs/plans/2026-08-23-df1-snapshot-lifecycle.md, T2): bounded
             // read, no session id available on this surface (freshness bound
             // only) — an orphaned snapshot must age out here too, not just on the

package/dist/memory.d.ts

@@ -203,6 +203,9 @@ export declare function confidenceLabel(entry: MemoryEntry, now?: Date): {
  * returns 'stale'. Otherwise returns the stored confidence value.
  */
 export declare function resolveConfidence(entry: MemoryEntry, now?: Date): ConfidenceLevel;
+export declare const DEFAULT_HALF_LIFE_DAYS = 7;
+export declare const AUTO_DELETABLE_SQL = "pinned = 0 AND kind != 'raw'";
+export declare function canAutoDelete(entry: Pick<MemoryEntry, 'pinned' | 'kind'>): boolean;
 /**
  * Create a new memory entry with defaults.
  */

package/dist/memory.js

@@ -296,6 +296,12 @@ export function confidenceLabel(entry, now = evalNow()) {
 export function resolveConfidence(entry, now = evalNow()) {
     return isAgedOut(entry, now) ? 'stale' : entry.confidence;
 }
+export const DEFAULT_HALF_LIFE_DAYS = 7;
+// Pinned means keep; raw rows leave only through archiveRawMemory. The SQL twin guards the DELETE itself.
+export const AUTO_DELETABLE_SQL = "pinned = 0 AND kind != 'raw'";
+export function canAutoDelete(entry) {
+    return !entry.pinned && entry.kind !== 'raw';
+}
 /**
  * Create a new memory entry with defaults.
  */
@@ -314,7 +320,7 @@ export function createMemory(content, options = {}) {
     const emotional_valence = options.emotional_valence ?? inferValence(tags);
     const schema_fit = options.schema_fit ?? 0.5;
     const partial = { tags, schema_fit };
-    const half_life_days = deriveHalfLife(options.baseHalfLifeDays ?? 7, partial);
+    const half_life_days = deriveHalfLife(options.baseHalfLifeDays ?? DEFAULT_HALF_LIFE_DAYS, partial);
     const entry = {
         id: generateId(layer === Layer.Semantic ? 'sem' : 'mem'),
         created: now,

package/dist/physics-state.js

@@ -105,7 +105,10 @@ export function savePhysicsState(db, particles) {
         db.exec('COMMIT');
     }
     catch (error) {
-        db.exec('ROLLBACK');
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* already rolled back; keep the original error */ }
         throw error;
     }
 }

package/dist/raw-archive.js

@@ -80,8 +80,11 @@ export function archiveRawMemory(db, id, opts) {
         db.exec('RELEASE SAVEPOINT archive_raw');
     }
     catch (e) {
-        db.exec('ROLLBACK TO SAVEPOINT archive_raw');
-        db.exec('RELEASE SAVEPOINT archive_raw');
+        try {
+            db.exec('ROLLBACK TO SAVEPOINT archive_raw');
+            db.exec('RELEASE SAVEPOINT archive_raw');
+        }
+        catch { /* savepoint already discarded; keep the original error */ }
         throw e;
     }
 }

package/dist/recall-trace.js

@@ -67,7 +67,10 @@ export function writeRecallTrace(db, input) {
             return traceId;
         }
         catch (error) {
-            db.exec('ROLLBACK');
+            try {
+                db.exec('ROLLBACK');
+            }
+            catch { /* already rolled back; keep the original error */ }
             throw error;
         }
     }

package/dist/refine-llm.js

@@ -14,6 +14,7 @@
  */
 import { Layer } from './memory.js';
 import { loadAllEntries, readEntry, writeEntry } from './store.js';
+import { redactSecrets } from './secret-detect.js';
 const REFINED_TAG = 'llm-refined';
 const CONSOLIDATED_MARKERS = [
     '[Consolidated from',
@@ -29,7 +30,7 @@ export async function refineSemanticMemory(merged, sources, opts) {
     const fetchFn = opts.fetcher ?? fetch;
     const sourceBlock = sources
         .slice(0, 8)
-        .map((s, i) => `[source ${i + 1}] ${s.content.slice(0, 400)}`)
+        .map((s, i) => `[source ${i + 1}] ${redactSecrets(s.content).slice(0, 400)}`)
         .join('\n\n');
     const prompt = `You are refining a semantic memory in an agent's memory store. The rule-based consolidator merged several related episodic memories into one, but the output is clumsy. Produce a single coherent semantic memory that captures the underlying principle.
 
@@ -41,7 +42,7 @@ Rules:
 - Do NOT include the "[Consolidated from N ...]" marker.
 
 Current merged content:
-${merged}
+${redactSecrets(merged)}
 
 Source memories (up to 8 shown):
 ${sourceBlock}`;

package/dist/rerankers/jev.js

@@ -1,4 +1,5 @@
 import { crossEncoderReranker } from './cross-encoder.js';
+import { redactSecrets } from '../secret-detect.js';
 const ENDPOINT = 'https://api.typesafe.ai/v1/systemone';
 const DEFAULT_TIMEOUT_MS = 5_000;
 const TRUNCATE_CHARS = 1200;
@@ -32,8 +33,8 @@ async function requestScores(query, head) {
     const key = process.env.TYPESAFE_API_KEY;
     if (!key)
         throw new Error('TYPESAFE_API_KEY not set');
-    const lines = head.map((r, i) => `[${i + 1}] ${truncate(r.entry.content, TRUNCATE_CHARS)}`);
-    const state = `Query: ${query}\n\nNumbered candidate memories from an AI coding agent's project store:\n\n${lines.join('\n\n')}`;
+    const lines = head.map((r, i) => `[${i + 1}] ${truncate(redactSecrets(r.entry.content), TRUNCATE_CHARS)}`);
+    const state = `Query: ${redactSecrets(query)}\n\nNumbered candidate memories from an AI coding agent's project store:\n\n${lines.join('\n\n')}`;
     const questions = {};
     for (let i = 1; i <= head.length; i++) {
         questions[`c${i}`] = {

package/dist/rerankers/llm.js

@@ -1,3 +1,4 @@
+import { redactSecrets } from '../secret-detect.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
 /**
  * Track 3 reranker: listwise LLM rerank. Uses a customer-supplied
@@ -21,8 +22,8 @@ export const llmReranker = async (query, results, options) => {
     const head = results.slice(0, topK);
     const prompt = [
         `Rerank the candidates below by relevance to the query. Output a JSON array of indices (zero-indexed) in best-first order.`,
-        `Query: ${query}`,
-        ...head.map((r, i) => `[${i}] ${r.entry.content}`),
+        `Query: ${redactSecrets(query)}`,
+        ...head.map((r, i) => `[${i}] ${redactSecrets(r.entry.content)}`),
         `Output format: [<int>, <int>, ...] with all ${head.length} indices.`,
     ].join('\n');
     const timeoutMs = Number.parseInt(process.env.HIPPO_LLM_RERANKER_TIMEOUT_MS ?? '', 10) || DEFAULT_TIMEOUT_MS;

package/dist/search.js

@@ -237,8 +237,8 @@ export async function hybridSearch(query, entries, options = {}) {
     if (options.hippoRoot) {
         try {
             const provider = resolveEmbeddingProvider(options.hippoRoot);
-            if (provider.isAvailable() && !embeddingModelRequiresReindex(options.hippoRoot, provider.id)) {
-                const idx = loadEmbeddingIndex(options.hippoRoot);
+            const idx = provider.isAvailable() ? loadEmbeddingIndex(options.hippoRoot) : {};
+            if (provider.isAvailable() && !embeddingModelRequiresReindex(options.hippoRoot, provider.id, idx)) {
                 // Only spend a (possibly paid, off-box) query embedding when at least one
                 // of THIS search's entries has a cached vector to compare against. An
                 // index of only orphaned / out-of-scope vectors yields a meaningless
@@ -511,7 +511,7 @@ export async function hybridSearch(query, entries, options = {}) {
         const head = ordered.slice(0, topK);
         const tail = ordered.slice(topK);
         const rerankInputWithRank = head.map((r, i) => ({ ...r, preRerankRank: i + 1 }));
-        const reranked = await options.reranker(query, rerankInputWithRank, options.rerankerOptions);
+        const reranked = await options.reranker(query, rerankInputWithRank, { ...options.rerankerOptions, topK });
         const withPostRank = reranked.map((r, i) => ({ ...r, postRerankRank: i + 1 }));
         ordered = [...withPostRank, ...tail];
     }

package/dist/server.d.ts

@@ -15,6 +15,8 @@ export interface ServeOpts {
     hippoRoot: string;
     port?: number;
     host?: string;
+    /** Stop and exit on SIGINT/SIGTERM. Only `hippo serve` owns the process, so only it sets this. */
+    handleSignals?: boolean;
 }
 /**
  * Recognise loopback remote addresses. Node reports IPv6-mapped IPv4 as
@@ -22,6 +24,9 @@ export interface ServeOpts {
  * the bare v4 and v6 loopbacks. Anything else is treated as remote.
  */
 export declare function isLoopback(remoteAddress: string | undefined): boolean;
+export declare const LOOPBACK_HOST_HEADER: RegExp;
+/** A browser request sent by another site. Non-browser clients send neither header and pass. */
+export declare function isCrossSite(req: IncomingMessage): boolean;
 /**
  * Rate-limit key for a request. Defaults to the socket's remote address.
  *