hippo-memory 1.68.0 → 1.70.0

package/dist/{server-detect.js → server/server-detect.js}

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
+import { envHealthProbeMs } from '../util/env.js';
 // Pidfile sits directly inside hippoRoot. `hippoRoot` is the `.hippo`
 // directory itself (the same convention used by api.ts / store.ts /
 // openHippoDb), so this resolves to `${hippoRoot}/server.pid`.
@@ -8,7 +9,7 @@ const PIDFILE = 'server.pid';
  * How long detectServer waits for the `/health` liveness probe before
  * treating the pidfile as stale. Short by design: the probe only fires on
  * the rare path where a pidfile exists and its pid is live, and the target
- * is always loopback, so a healthy server answers well within this bound.
+ * is always loopback, so a healthy server answers well within this bound. HIPPO_HEALTH_PROBE_MS overrides it.
  */
 const HEALTH_PROBE_TIMEOUT_MS = 300;
 /**
@@ -84,7 +85,7 @@ async function healthMatchesPidfile(hippoRoot, info) {
     // returns null WITHOUT unlinking. The pidfile survives for the next probe.
     try {
         const res = await fetch(`${info.url}/health`, {
-            signal: AbortSignal.timeout(HEALTH_PROBE_TIMEOUT_MS),
+            signal: AbortSignal.timeout(envHealthProbeMs() ?? HEALTH_PROBE_TIMEOUT_MS),
         });
         if (!res.ok || !res.body) {
             removePidfile(hippoRoot);

package/dist/server/sleep-child.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sleep-child.d.ts.map

package/dist/server/sleep-child.js

@@ -0,0 +1,19 @@
+// Entry of the process that runs one POST /v1/sleep; sleep-offload.ts starts it and nothing imports it.
+// The sleep module alone: the api barrel loads far more than one sleep needs, and every sleep pays for the start.
+import { sleep } from '../api/sleep.js';
+import { isStoreBusy, runWithRequestStores, SERVER_DB_WAIT_MS } from '../db/index.js';
+import { errorMessage } from '../util/log.js';
+function failed(err) {
+    return { ok: false, busy: isStoreBusy(err), message: errorMessage(err), stack: err instanceof Error ? err.stack : undefined };
+}
+process.once('message', (message) => {
+    // SAFETY: sleep-offload.ts is the only writer on this channel and sends exactly one SleepJob.
+    const job = message;
+    const ctx = { hippoRoot: job.hippoRoot, tenantId: job.tenantId, actor: job.actor };
+    // The server's own request scope and lock wait, so a busy store answers as it did when sleep ran in the server.
+    runWithRequestStores(() => sleep(ctx, job.opts), { busyWaitMs: SERVER_DB_WAIT_MS })
+        .then((result) => ({ ok: true, result }), failed)
+        // Exit only once the reply is written, or the parent could see the process end first.
+        .then((reply) => process.send?.(reply, () => process.exit(0)));
+});
+//# sourceMappingURL=sleep-child.js.map

package/dist/server/sleep-offload.d.ts

@@ -0,0 +1,20 @@
+import { type Actor, type Context, type SleepOpts, type SleepResult } from '../api/index.js';
+/** What the child needs to rebuild the request's context; the store handle itself cannot cross a process boundary. */
+export interface SleepJob {
+    readonly hippoRoot: string;
+    readonly tenantId: string;
+    readonly actor: Actor;
+    readonly opts: SleepOpts;
+}
+export type SleepReply = {
+    readonly ok: true;
+    readonly result: SleepResult;
+} | {
+    readonly ok: false;
+    readonly busy: boolean;
+    readonly message: string;
+    readonly stack?: string;
+};
+/** `sleep` for the HTTP route: same result and errors, run outside the serving process and stopped at the deadline (10 minutes, or HIPPO_SLEEP_TIMEOUT_MS). */
+export declare function sleepInChild(ctx: Context, opts: SleepOpts): Promise<SleepResult>;
+//# sourceMappingURL=sleep-offload.d.ts.map

package/dist/server/sleep-offload.js

@@ -0,0 +1,70 @@
+// POST /v1/sleep runs its consolidation in a child process, so the server keeps answering and a stuck run can be stopped.
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { sleep } from '../api/index.js';
+import { StoreBusyError } from '../db/index.js';
+import { envSleepTimeoutMs } from '../util/env.js';
+import { HttpError } from '../util/http-util.js';
+const DEFAULT_SLEEP_DEADLINE_MS = 600_000;
+// Resolved from the package root, so a server run from TypeScript source starts the same built file.
+const CHILD_ENTRY = fileURLToPath(new URL('../../dist/server/sleep-child.js', import.meta.url));
+function failureOf(reply, code, signal) {
+    if (!reply || reply.ok)
+        return new Error(`sleep process ended without an answer (code ${code}, signal ${signal})`);
+    // A lock the child could not get is the same retryable 503 an in-process sleep gave.
+    if (reply.busy)
+        return new StoreBusyError(reply.message);
+    const failure = new Error(reply.message);
+    if (reply.stack)
+        failure.stack = reply.stack;
+    return failure;
+}
+function runInChild(job) {
+    const deadlineMs = envSleepTimeoutMs() ?? DEFAULT_SLEEP_DEADLINE_MS;
+    return new Promise((resolve, reject) => {
+        // The child's stderr is the server's log, so Node's SQLite notice would repeat there on every sleep.
+        const child = spawn(process.execPath, ['--disable-warning=ExperimentalWarning', CHILD_ENTRY], { stdio: ['ignore', 'inherit', 'inherit', 'ipc'], windowsHide: true });
+        let reply;
+        let timedOut = false;
+        // SIGKILL because the child is inside synchronous SQLite work and cannot run a handler; the OS drops its write lock.
+        const timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, deadlineMs);
+        child.once('message', (message) => {
+            // SAFETY: sleep-child.ts is the only writer on this channel and sends exactly one SleepReply.
+            reply = message;
+        });
+        child.once('error', (err) => { clearTimeout(timer); reject(err); });
+        // 'close' and not 'exit': it waits for the channel to drain, so the reply is in hand and the child's store handles are gone.
+        child.once('close', (code, signal) => {
+            clearTimeout(timer);
+            if (timedOut)
+                reject(new HttpError(504, `sleep did not finish within ${deadlineMs} ms and was stopped; the next sleep carries on from there`));
+            else if (reply?.ok)
+                resolve(reply.result);
+            else
+                reject(failureOf(reply, code, signal));
+        });
+        child.send(job);
+    });
+}
+let turn = Promise.resolve();
+// One running and one waiting: each further sleep would only hold a request open behind work the waiting one already covers.
+const MAX_SLEEPS_IN_LINE = 2;
+const SLEEP_RETRY_AFTER_SEC = 30;
+let inLine = 0;
+/** `sleep` for the HTTP route: same result and errors, run outside the serving process and stopped at the deadline (10 minutes, or HIPPO_SLEEP_TIMEOUT_MS). */
+export function sleepInChild(ctx, opts) {
+    // The child reopens the store by path, which only SQLite has; any other store keeps sleep's own refusal.
+    if (ctx.store && ctx.store.kind !== 'sqlite')
+        return sleep(ctx, opts);
+    if (inLine >= MAX_SLEEPS_IN_LINE) {
+        return Promise.reject(new HttpError(503, 'a sleep is already running and another is waiting; retry when one has finished', SLEEP_RETRY_AFTER_SEC));
+    }
+    inLine += 1;
+    const job = { hippoRoot: ctx.hippoRoot, tenantId: ctx.tenantId, actor: ctx.actor, opts };
+    // One sleep at a time, as on the server's single thread: a second request waits its turn and does not fight the first for the write lock.
+    const run = turn.then(() => runInChild(job));
+    // A failed sleep reaches its own request through `run`; the queue only needs to know the turn is over.
+    turn = run.then(() => undefined, () => undefined).finally(() => { inLine -= 1; });
+    return run;
+}
+//# sourceMappingURL=sleep-offload.js.map

package/dist/server/tls.d.ts

@@ -0,0 +1,6 @@
+import { type RequestListener, type Server } from 'node:http';
+import type { ServeOpts } from './types.js';
+export declare function createListener(tls: ServeOpts['tls'], onRequest: RequestListener): Server;
+/** Said once at boot: a non-loopback bind without TLS sends every key and memory over the network as plain text. */
+export declare function warnIfCleartext(host: string, tls: ServeOpts['tls'], loopbackHosts: ReadonlySet<string>): void;
+//# sourceMappingURL=tls.d.ts.map

package/dist/server/tls.js

@@ -0,0 +1,24 @@
+// The serve() listener: node:https when a certificate is given, else node:http and a boot warning off loopback.
+import { createServer as createHttpServer } from 'node:http';
+import { createServer as createHttpsServer } from 'node:https';
+import { errorMessage, log } from '../util/log.js';
+export function createListener(tls, onRequest) {
+    if (!tls)
+        return createHttpServer(onRequest);
+    try {
+        // Explicit so the floor does not move with the runtime's default.
+        return createHttpsServer({ cert: tls.cert, key: tls.key, minVersion: 'TLSv1.2' }, onRequest);
+    }
+    catch (err) {
+        // OpenSSL's own text names no file, so the operator would not know which input was refused.
+        throw new Error(`hippo serve: the TLS certificate or key was refused: ${errorMessage(err)}`, { cause: err });
+    }
+}
+/** Said once at boot: a non-loopback bind without TLS sends every key and memory over the network as plain text. */
+export function warnIfCleartext(host, tls, loopbackHosts) {
+    if (tls || loopbackHosts.has(host))
+        return;
+    log.warn(`serve: listening on ${host} without TLS, so API keys and memory text travel in cleartext unless a TLS-terminating proxy sits in front. ` +
+        'To serve HTTPS directly, pass --tls-cert and --tls-key (or set HIPPO_TLS_CERT and HIPPO_TLS_KEY).');
+}
+//# sourceMappingURL=tls.js.map

package/dist/server/types.d.ts

@@ -1,8 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Context } from '../api.js';
-import type { JsonValue } from '../json.js';
-import type { RateLimiter } from '../rate-limit.js';
-import type { HippoStore, StoreGroup } from '../store-port.js';
+import type { Context } from '../api/index.js';
+import type { JsonValue } from '../util/json.js';
+import type { RateLimiter } from './rate-limit.js';
+import type { HippoStore, StoreGroup } from '../store/index.js';
 export interface ServerHandle {
     port: number;
     url: string;
@@ -46,15 +46,24 @@ export interface ServeOpts {
     authResolverTimeoutMs?: number;
     port?: number;
     host?: string;
-    /** Stop and exit on SIGINT/SIGTERM. Only `hippo serve` owns the process, so only it sets this. */
+    /** Stop and exit on SIGINT/SIGTERM, and drain then exit 1 on an uncaught exception or unhandled rejection. Only `hippo serve` owns the process, so only it sets this. */
     handleSignals?: boolean;
     /** How long stop() lets in-flight requests finish before closing their sockets; defaults to 5000 ms. */
     shutdownDrainMs?: number;
+    /** How long a request may stay unanswered before one warn names it; the request itself is left alone. Defaults to 60000 ms. */
+    slowRequestWarnMs?: number;
     /** Defaults to hippo.db under `hippoRoot`. A store of another kind runs only the routes ported to it; its caller closes it. */
     store?: HippoStore;
     autoSleep?: false;
     routes?: readonly AddonRoute[];
     mintBodyDeadlineMs?: number;
+    /** Tests only: shortens the wait for a signed webhook's body, which defaults to 10 s. */
+    webhookBodyDeadlineMs?: number;
+    /** PEM certificate and key: serve() then answers HTTPS only. Unset means cleartext HTTP, which needs a TLS-terminating proxy in front on any non-loopback bind. */
+    tls?: {
+        cert: string | Buffer;
+        key: string | Buffer;
+    };
     /** Static JSON served to anyone at GET <path>; built once at boot and never authenticated, so it must hold nothing secret. */
     publicJson?: Readonly<Record<string, JsonValue>>;
     /** Request limits: perCaller after auth; perAddress replaces HIPPO_V1_RPS when set, 'off' disables it; failedAuthPerAddress guards scrypt. */
@@ -77,11 +86,20 @@ export interface RouteRequest {
     opts: ResolvedServeOpts;
     query: URLSearchParams;
 }
-/** One /v1 route: an exact path, a matchPath pattern, or a regex, each paired with the handler for one method. Under another store it runs only when that store has its `storeReady` group. */
+/** A route's store status: a `storeReady` group, a `sqliteOnly` reason, or neither while it waits for a group; never both. */
+type StoreStatus = {
+    storeReady?: StoreGroup;
+    sqliteOnly?: never;
+} | {
+    sqliteOnly: string;
+    storeReady?: never;
+};
+/** One /v1 route: an exact path, a matchPath pattern, or a regex, each paired with the handler for one method. Under another store it runs only when that store has its `storeReady` group; a `sqliteOnly` route never does.
+ *  `loop: 'off'` declares that the route's SQLite work runs on a worker thread, so its handler opens no hippo.db on the server thread. */
 export type Route = {
     method: string;
-    storeReady?: StoreGroup;
-} & ({
+    loop?: 'off';
+} & StoreStatus & ({
     path: string;
     handler: (r: RouteRequest) => Promise<void>;
 } | {
@@ -91,4 +109,5 @@ export type Route = {
     regex: RegExp;
     handler: (r: RouteRequest, match: RegExpMatchArray) => Promise<void>;
 });
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/server/validation.d.ts

@@ -1,9 +1,8 @@
 import type { IncomingMessage } from 'node:http';
-import type { Context, RememberOpts } from '../api.js';
-import { type JsonValue } from '../json.js';
-export declare function isJsonNumber(value: JsonValue | undefined): value is number;
-export declare function isJsonBoolean(value: JsonValue | undefined): value is boolean;
+import type { Context, RememberOpts } from '../api/index.js';
+import { type JsonValue } from '../util/json.js';
 export declare function isSetMember<T extends string>(set: ReadonlySet<T>, value: string): value is T;
+export declare const MAX_LIST_LIMIT = 1000;
 export declare function parseListLimit(limitRaw: string | null, defaultLimit?: number, maxLimit?: number): number;
 /** `_authed` is proof the caller passed auth, so a full-size body is read only for an authenticated caller; the key mint reads first under its own small cap. */
 export declare function parseJsonBody(req: IncomingMessage, _authed: Context): Promise<Record<string, JsonValue>>;

package/dist/server/validation.js

@@ -1,11 +1,5 @@
-import { HttpError, isJsonObjectRecord, MAX_ID_LEN, readBody } from '../http-util.js';
-import { isJsonString } from '../json.js';
-export function isJsonNumber(value) {
-    return typeof value === 'number';
-}
-export function isJsonBoolean(value) {
-    return typeof value === 'boolean';
-}
+import { HttpError, MAX_ID_LEN, readBody } from '../util/http-util.js';
+import { isJsonString, isJsonObject } from '../util/json.js';
 // Runtime membership check for a `ReadonlySet<T>` of string-literal union
 // members, used at every `body` field validated against a VALID_* set below.
 // Set<T>.has(value: T) itself gives no narrowing (its parameter type is T,
@@ -21,7 +15,8 @@ export function isSetMember(set, value) {
 }
 // Number.isInteger, not isFinite: SQLite `LIMIT ?` rejects "1.5" with a 500.
 // Shared by every first-class-object list route so the guard cannot drift.
-export function parseListLimit(limitRaw, defaultLimit = 100, maxLimit = 1000) {
+export const MAX_LIST_LIMIT = 1000;
+export function parseListLimit(limitRaw, defaultLimit = 100, maxLimit = MAX_LIST_LIMIT) {
     if (limitRaw === null)
         return defaultLimit;
     const limit = Number(limitRaw);
@@ -39,7 +34,7 @@ export function parseJsonObjectText(raw) {
         return {};
     try {
         const parsed = JSON.parse(raw);
-        if (!isJsonObjectRecord(parsed)) {
+        if (!isJsonObject(parsed)) {
             throw new HttpError(400, 'request body must be a JSON object');
         }
         return parsed;
@@ -67,7 +62,7 @@ export function getCallerProject(body) {
     const v = body.project;
     if (v === undefined || v === null)
         return undefined;
-    if (!isJsonObjectRecord(v) || !isJsonString(v.name)) {
+    if (!isJsonObject(v) || !isJsonString(v.name)) {
         throw new HttpError(400, 'project must be an object with a "name" string');
     }
     if (v.aliases === undefined)

package/dist/server.d.ts

@@ -1,68 +1,59 @@
-import { type Actor, authCreateSelf, type AuthCreateSelfOpts, type AuthCreateSelfResult, authRevoke, type AuthRevokeReply, type AuthRevokeResult, type Context } from './api.js';
-import { ForbiddenError, NotFoundError } from './api-errors.js';
-import type { ServeOpts, ServerHandle } from './server/types.js';
+import { type Actor, authCreateSelf, type AuthCreateSelfOpts, type AuthCreateSelfResult, authRevoke, type AuthRevokeReply, type AuthRevokeResult, type Context } from './api/index.js';
+import { ForbiddenError, NotFoundError } from './core/api-errors.js';
+export { serve } from './server/boot.js';
 export { authCreateSelf, authRevoke, ForbiddenError, NotFoundError, type AuthCreateSelfOpts, type AuthCreateSelfResult, type AuthRevokeReply, type AuthRevokeResult, type Context, type Actor, };
-export { isCrossSite, LOOPBACK_HOST_HEADER } from './http-util.js';
+export { isCrossSite, LOOPBACK_HOST_HEADER } from './util/http-util.js';
 export { __resetSessionRecallHistoryHttp } from './server/routes/recall.js';
 export { clientIpForRateLimit } from './server/client-ip.js';
 export { isLoopback, isReservedActor } from './server/auth.js';
 export type { AddonCall, AddonRoute, AuthResolver, RateLimitSpec, ResolvedBearer, ServeOpts, ServerHandle } from './server/types.js';
-export { HttpError } from './http-util.js';
-export { promptHookContext, type CallerProject } from './prompt-hook.js';
-export type { JsonValue } from './json.js';
+export { HttpError } from './util/http-util.js';
+export { promptHookContext, type CallerProject } from './api/prompt-hook.js';
+export type { JsonValue } from './util/json.js';
 export { captureSessionTexts, type SessionCaptureRequest, type SessionCaptureResult } from './capture/session-texts.js';
-export { hasGroup, sqliteStore, type HippoStore, type KeyAudit, type KeyListQuery, type KeyMint, type KeyRevoke, type KeyWrites, type RecallSearchArgs, type RecallWrites, type SelfKeyMint, type StoreGroup, type StoreGroups, type VectorReads, type VectorBackfillQuery, type VectorRowWrite, type VectorWrite, type VectorWriteResult, type VectorWrites, } from './store-port.js';
+export { hasGroup, sqliteStore, type AmbientCandidateRequest, type ContextReads, type EntryRemoval, type EntryTarget, type EntryWrite, type EntryWrites, type HippoStore, type KeyAudit, type KeyListQuery, type KeyMint, type KeyRevoke, type KeyWrites, type OutcomeWrite, type RawArchive, type RecallSearchArgs, type RecallWrites, type SelfKeyMint, type StoreGroup, type StoreGroups, type SupersedeWrite, type VectorReads, type VectorBackfillQuery, type VectorRowWrite, type VectorWrite, type VectorWriteResult, type VectorWrites, } from './store/index.js';
+export { entryAfterOutcome } from './core/memory.js';
+export { rejectionDigest, RejectedValueError } from './store/rejection.js';
+export { ownScopeTouches } from './store/recall-scope.js';
+export { BadRequestError, ConflictError } from './core/api-errors.js';
 export type { HippoDbContext, StoreReply } from './api/types.js';
-export type { ApiKeyListItem, ApiKeyListRow, ApiKeyRecord, ListApiKeysOpts, NewApiKey } from './auth.js';
-export type { KeysetPosition } from './keyset.js';
-export type { AppendAuditOpts, AuditEvent, ListAuditAfterOpts } from './audit.js';
+export type { ApiKeyListItem, ApiKeyListRow, ApiKeyRecord, ListApiKeysOpts, NewApiKey } from './store/auth.js';
+export type { KeysetPosition } from './util/keyset.js';
+export type { AppendAuditOpts, AuditEvent, ListAuditAfterOpts } from './store/audit.js';
 export type { ContinuityBlock } from './api/recall-types.js';
-export type { ActiveGoals, GetActiveGoalsOpts, Goal, GoalRecallLogRow, RetrievalPolicy } from './goals.js';
-export type { MemoryEntry } from './memory.js';
-export type { ClassResolution, PlanningFallacyEvidence } from './predictions/planning-fallacy.js';
-export type { PredictionBaserate } from './predictions/store.js';
-export type { RecallTraceInput } from './recall-trace.js';
+export type { ActiveGoals, GetActiveGoalsOpts, Goal, GoalRecallLogRow, RetrievalPolicy } from './store/goals.js';
+export type { MemoryEntry } from './core/memory.js';
+export type { ClassResolution, PlanningFallacyEvidence } from './store/planning-fallacy-evidence.js';
+export type { PredictionBaserate } from './store/predictions.js';
+export type { RecallTraceInput } from './store/recall-trace.js';
 export type { StrengthenOptions } from './store/entry-writes.js';
 export type { OriginFilter, RecallScopeFilter, VectorCandidateSpec } from './store/search-rows.js';
 export type { ContinuityKey } from './store/sessions.js';
-export type { TokenUse } from './token-ledger.js';
-export type { EmbeddingIndexState } from './embeddings.js';
-export type { PhysicsParticle } from './physics.js';
-export { StoreBusyError } from './db.js';
-export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows, type VectorMatch, type VectorRow } from './vector-store.js';
-export { bufferToFloat32, float32ToBuffer } from './physics-state.js';
-export { replacesIndex } from './embeddings.js';
-export { OTHER_STORE_MARKER, OtherStoreFolderError, withSqliteAllowed } from './db.js';
-export { authCreate, type AuthCreateOpts, type AuthCreateResult } from './api.js';
-export { isSharedStore } from './config.js';
-export { ownerOrSubject } from './api.js';
-export { bindSessionOwner } from './session-owners.js';
+export type { SessionEvent, TaskSnapshot } from './store/rows.js';
+export type { SessionHandoff } from './core/handoff.js';
+export type { AmbientLoadResult, AmbientRecallRequest, ContextCandidateFilter, RecentOrigins } from './store/candidates.js';
+export type { AmbientStoreFilter } from './store/ambient.js';
+export type { AmbientTallies } from './core/ambient.js';
+export type { TokenUse } from './store/token-ledger.js';
+export type { EmbeddingIndexState } from './store/embeddings/index.js';
+export type { PhysicsParticle } from './core/physics.js';
+export { StoreBusyError } from './db/index.js';
+export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows, type VectorMatch, type VectorRow } from './db/vector-store.js';
+export { bufferToFloat32, float32ToBuffer } from './db/physics-state.js';
+export { replacesIndex } from './store/embeddings/index.js';
+export { passesScopeFilterForRecall, RECALL_DEFAULT_DENY_SCOPES } from './store/recall-scope.js';
+export { SECRET_TAGS } from './util/secret-detect.js';
+export { tallyAmbientEntries } from './core/ambient.js';
+export { ftsTermParts, rarestFtsQuery } from './core/prompt-recall.js';
+export { OTHER_STORE_MARKER, OtherStoreFolderError, withSqliteAllowed } from './db/index.js';
+export { authCreate, type AuthCreateOpts, type AuthCreateResult } from './api/index.js';
+export { isSharedStore } from './core/config.js';
+export { ownerOrSubject } from './api/index.js';
+export { bindSessionOwner } from './api/session-owners.js';
 export { preCompactForCaller, type CallerHookOutput, type CallerPreCompactRequest } from './capture/pre-compact-caller.js';
 export { compactResumeForCaller, type CallerCompactResumeRequest } from './capture/compact-resume-caller.js';
 export { saveCompactionItemsForCaller, type CallerItemsRequest, type CallerItemsResult } from './capture/compaction-items-caller.js';
 export { captureFailureForCaller, type CallerFailureRequest, type CallerFailureResult } from './capture/failure-caller.js';
 export { sessionEndHandoffForCaller, type CallerEvidence, type CallerSessionEndRequest, type CallerSessionEndResult } from './capture/session-end-caller.js';
 export type { WorkingState } from './capture/working-state.js';
-/**
- * Boot the HTTP daemon on host:port and write the pidfile under hippoRoot.
- *
- * Refuses non-loopback hosts at boot unless
- * HIPPO_REQUIRE_AUTH=1 is set. The auth middleware (buildContextWithAuth /
- * requireAuth) has shipped and every route checks it except GET /health
- * (public by design for platform health checks) and the two connector
- * webhooks in PUBLIC_ROUTES, which are HMAC-gated by their own signing
- * secrets and 404 when those secrets are unset, and any publicJson GET path. But the loopback
- * no-auth fallback inside buildContextWithAuth still admits unauthenticated
- * requests from a loopback remote address (unless they carry Forwarded,
- * X-Forwarded-For/-Host/-Proto, X-Real-IP, Cf-Connecting-Ip or True-Client-Ip, which mark a same-host proxy and get
- * a 401 like any keyless remote request), so binding to a non-loopback host
- * is only safe once that fallback is disabled with HIPPO_REQUIRE_AUTH=1,
- * which forces every request (loopback or not) through Bearer-token
- * validation. Without that env var set, a non-loopback bind would expose the
- * DB to the network with no auth, so we fail fast instead.
- *
- * Use port: 0 in tests to bind to an ephemeral port and read the actual
- * port back via server.address() after listen.
- */
-export declare function serve(opts: ServeOpts): Promise<ServerHandle>;
 //# sourceMappingURL=server.d.ts.map