hippo-memory 1.60.0 → 1.62.0

package/dist/dashboard-snapshot.d.ts

@@ -0,0 +1,138 @@
+import { Layer as MemoryLayer, type MemoryEntry } from './memory.js';
+import type { MemoryConflict } from './store/rows.js';
+import type { Band, ChipCounts, Layer, Overview, ProjectKind, ProjectSummary, ScatterGrid, ScatterPoints } from './dashboard-types.js';
+export declare const DAY_MS = 86400000;
+export declare const LAYERS: readonly Layer[];
+export declare const BANDS: readonly Band[];
+/** An outside commit rebuilds the snapshot at most this often. */
+export declare const COALESCE_MS = 10000;
+/** Projected strengths track the clock, so the snapshot is rebuilt at least this often. */
+export declare const TTL_MS: number;
+/** The one predicate for "shown on the dashboard": not superseded, not archived, not quarantined. */
+export declare function isLiveMemory(entry: Pick<MemoryEntry, 'superseded_by' | 'kind' | 'scope'>): boolean;
+/** Wire key, display name and kind of a project. */
+export interface ProjectIdentity {
+    key: string;
+    name: string;
+    kind: ProjectKind;
+}
+/** Wire key, display name and kind for an `origin_project` value. */
+export declare function projectIdentity(origin: string | null | undefined): ProjectIdentity;
+/** Index of a layer in the wire order `LAYERS`. */
+export declare function layerIndex(layer: MemoryLayer): number;
+/** Per-memory numbers shared by the snapshot build and the single-memory detail route. */
+export interface MemoryFacts {
+    strength: number;
+    strength7d: number;
+    strength30d: number;
+    band: number;
+    layer: number;
+    ageDays: number;
+    lastRetrievedDays: number;
+    confidence: string;
+    agedOut: boolean;
+    wrong: boolean;
+}
+/** Strength now and at +7d and +30d, band, age and the confidence split for one entry at `nowMs`. */
+export declare function memoryFacts(entry: MemoryEntry, nowMs: number): MemoryFacts;
+/** One live memory as the snapshot holds it: numbers and short strings only, never the full entry. */
+export interface Fact {
+    id: string;
+    head: string;
+    truncated: boolean;
+    lower: string;
+    tagsLower: string;
+    layer: number;
+    band: number;
+    strength: number;
+    strength7d: number;
+    strength30d: number;
+    retrievals: number;
+    lastRetrievedDays: number;
+    ageDays: number;
+    confidence: string;
+    confidenceRank: number;
+    scope: string | null;
+    pinned: boolean;
+    wrong: boolean;
+    inConflict: boolean;
+    embedded: boolean;
+    project: number;
+    createdMs: number;
+}
+export interface ProjectAgg {
+    summary: ProjectSummary;
+    /** Indices into `Snapshot.facts`, in snapshot order. */
+    members: Int32Array;
+    firstCreatedMs: number;
+}
+export type Chip = 'all' | 'risk' | 'pinned' | 'conflict';
+/** A filtered memory set over one project: indices in sort order, chip counts, decay buckets, and per-chip lists built on demand. */
+export interface FilteredSet {
+    idx: Int32Array;
+    counts: ChipCounts;
+    decay: {
+        now: [number, number, number];
+        in7d: [number, number, number];
+        in30d: [number, number, number];
+        pinned: number;
+    };
+    byChip: Map<Chip, Int32Array>;
+}
+/** Small least-recently-used map; the oldest entry leaves when it is full. */
+export declare class Lru<V> {
+    private readonly capacity;
+    private readonly entries;
+    constructor(capacity: number);
+    get(key: string): V | undefined;
+    set(key: string, value: V): void;
+}
+/** Per-snapshot memo of query results; it dies with the snapshot, so no key needs a snapshot id. */
+export interface SnapshotMemo {
+    sorted: Lru<Int32Array>;
+    filtered: Lru<FilteredSet>;
+    scatter: Map<string, ScatterPoints | ScatterGrid>;
+    overview: Overview | null;
+}
+export interface Snapshot {
+    id: number;
+    tenantId: string;
+    nowMs: number;
+    facts: Fact[];
+    projects: ProjectAgg[];
+    byKey: Map<string, ProjectAgg>;
+    excluded: {
+        superseded: number;
+        archived: number;
+        quarantined: number;
+    };
+    /** Embedded share of live memories, or null when the store has no vector table yet. */
+    embeddingCoverage: number | null;
+    /** Open conflicts with both members live, each counted once. */
+    openConflicts: number;
+    memo: SnapshotMemo;
+}
+export interface SnapshotInput {
+    id: number;
+    tenantId: string;
+    nowMs: number;
+    entries: readonly MemoryEntry[];
+    openConflicts: readonly Pick<MemoryConflict, 'memory_a_id' | 'memory_b_id'>[];
+    embeddedIds: ReadonlySet<string> | null;
+}
+/** Builds the snapshot from already-loaded rows; it touches no store, so tests can feed it directly. */
+export declare function buildSnapshot(input: SnapshotInput): Snapshot;
+export interface SnapshotService {
+    /** The cached snapshot, or a new build when the cache key changed, the coalescing window allows it, or `fresh` is set. */
+    get(tenantId: string, fresh?: boolean): Snapshot;
+    /** Drops the cache after a dashboard write commits, so the next read rebuilds. */
+    invalidate(): void;
+    /** Id of the most recent build, which is what a client holding the last response still has. */
+    currentId(): number;
+    /** Ids with a vector as of the last build (a direct read before any build), so a detail read never rescans the vector table. */
+    embeddedIds(): ReadonlySet<string> | null;
+    close(): void;
+}
+/** Holds one read-only connection for its commit signal (`PRAGMA data_version`) and the snapshot cache; `now` dates the strength projections, `cacheClock` ages the cache. */
+export declare function createSnapshotService(hippoRoot: string, now: () => number, cacheClock?: () => number): SnapshotService;
+//# sourceMappingURL=dashboard-snapshot.d.ts.map

package/dist/dashboard-snapshot.js

@@ -0,0 +1,308 @@
+// The dashboard's read model: one in-memory snapshot of a tenant's live memories, grouped by origin project.
+// Pure build functions plus one cache; the queries over it live in dashboard-queries.ts.
+import * as fs from 'fs';
+import { calculateStrength, confidenceFacets, netWrong, Layer as MemoryLayer } from './memory.js';
+import { isQuarantineScope } from './quarantine.js';
+import { listMemoryConflicts } from './store/conflicts.js';
+import { loadAllEntries } from './store/entry-reads.js';
+import { closeHippoDb, getHippoDbPath, openHippoDbReadOnly } from './db.js';
+import { storedVectorIds } from './vector-store.js';
+export const DAY_MS = 86_400_000;
+export const LAYERS = ['buffer', 'episodic', 'semantic', 'trace'];
+// Wire order of `Band`, and the order the mockup sorts bands in.
+export const BANDS = ['pinned', 'strong', 'fading', 'atRisk'];
+const BAND_PINNED = 0;
+const BAND_STRONG = 1;
+const BAND_FADING = 2;
+const BAND_AT_RISK = 3;
+const CONFIDENCE_ORDER = ['verified', 'observed', 'inferred', 'stale'];
+const HEAD_CHARS = 240;
+/** An outside commit rebuilds the snapshot at most this often. */
+export const COALESCE_MS = 10_000;
+/** Projected strengths track the clock, so the snapshot is rebuilt at least this often. */
+export const TTL_MS = 5 * 60_000;
+/** The one predicate for "shown on the dashboard": not superseded, not archived, not quarantined. */
+export function isLiveMemory(entry) {
+    return !entry.superseded_by && (entry.kind === 'raw' || entry.kind === 'distilled') && !isQuarantineScope(entry.scope);
+}
+/** Wire key, display name and kind for an `origin_project` value. */
+export function projectIdentity(origin) {
+    if (origin === '')
+        return { key: 'global', name: 'Global', kind: 'global' };
+    if (origin === null || origin === undefined)
+        return { key: 'unassigned', name: 'Unassigned', kind: 'unassigned' };
+    return { key: `p:${origin}`, name: origin, kind: 'project' };
+}
+/** Index of a layer in the wire order `LAYERS`. */
+export function layerIndex(layer) {
+    switch (layer) {
+        case MemoryLayer.Buffer: return 0;
+        case MemoryLayer.Episodic: return 1;
+        case MemoryLayer.Semantic: return 2;
+        case MemoryLayer.Trace: return 3;
+    }
+}
+function daysBetween(thenIso, nowMs) {
+    const days = (nowMs - Date.parse(thenIso)) / DAY_MS;
+    return Number.isFinite(days) ? Math.max(0, days) : 0;
+}
+/** Strength now and at +7d and +30d, band, age and the confidence split for one entry at `nowMs`. */
+export function memoryFacts(entry, nowMs) {
+    const now = new Date(nowMs);
+    const strength = calculateStrength(entry, now);
+    const strength7d = calculateStrength(entry, new Date(nowMs + 7 * DAY_MS));
+    const strength30d = calculateStrength(entry, new Date(nowMs + 30 * DAY_MS));
+    const facets = confidenceFacets(entry, now);
+    const band = entry.pinned ? BAND_PINNED : strength30d < 0.2 ? BAND_AT_RISK : strength >= 0.5 ? BAND_STRONG : BAND_FADING;
+    return {
+        strength,
+        strength7d,
+        strength30d,
+        band,
+        layer: layerIndex(entry.layer),
+        ageDays: daysBetween(entry.created, nowMs),
+        lastRetrievedDays: daysBetween(entry.last_retrieved, nowMs),
+        confidence: facets.tier,
+        agedOut: facets.agedOut,
+        wrong: netWrong(entry) > 0,
+    };
+}
+/** Small least-recently-used map; the oldest entry leaves when it is full. */
+export class Lru {
+    capacity;
+    entries = new Map();
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    get(key) {
+        const value = this.entries.get(key);
+        if (value !== undefined) {
+            this.entries.delete(key);
+            this.entries.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        this.entries.delete(key);
+        this.entries.set(key, value);
+        if (this.entries.size > this.capacity) {
+            const oldest = this.entries.keys().next();
+            if (!oldest.done)
+                this.entries.delete(oldest.value);
+        }
+    }
+}
+function cutHead(content) {
+    if (content.length <= HEAD_CHARS)
+        return { head: content, truncated: false };
+    let end = HEAD_CHARS;
+    const last = content.charCodeAt(end - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        end -= 1;
+    return { head: content.slice(0, end), truncated: true };
+}
+function round1(value) {
+    return Math.round(value * 10) / 10;
+}
+function newDraft(identity) {
+    return {
+        summary: {
+            ...identity, live: 0, atRisk: 0, share: 0, pinned: 0, embedded: 0, openConflicts: 0, lastRetrievedDays: null,
+            bands: { pinned: 0, strong: 0, fading: 0, atRisk: 0 },
+            layers: { buffer: 0, episodic: 0, semantic: 0, trace: 0 },
+        },
+        members: [],
+        firstCreatedMs: Number.POSITIVE_INFINITY,
+        lastDays: Number.POSITIVE_INFINITY,
+    };
+}
+function toFact(entry, f, project, embedded, createdMs) {
+    const { head, truncated } = cutHead(entry.content);
+    const tier = CONFIDENCE_ORDER.indexOf(f.confidence);
+    return {
+        id: entry.id,
+        head,
+        truncated,
+        lower: entry.content.toLowerCase(),
+        tagsLower: entry.tags.length > 0 ? entry.tags.join('\n').toLowerCase() : '',
+        layer: f.layer,
+        band: f.band,
+        strength: f.strength,
+        strength7d: f.strength7d,
+        strength30d: f.strength30d,
+        retrievals: entry.retrieval_count,
+        lastRetrievedDays: f.lastRetrievedDays,
+        ageDays: f.ageDays,
+        confidence: f.confidence,
+        confidenceRank: tier === -1 ? CONFIDENCE_ORDER.length : tier,
+        scope: entry.scope,
+        pinned: entry.pinned,
+        wrong: f.wrong,
+        inConflict: false,
+        embedded,
+        project,
+        createdMs,
+    };
+}
+/** Builds the snapshot from already-loaded rows; it touches no store, so tests can feed it directly. */
+export function buildSnapshot(input) {
+    const { entries, embeddedIds, nowMs } = input;
+    const excluded = { superseded: 0, archived: 0, quarantined: 0 };
+    const facts = [];
+    const projectIndex = new Map();
+    const drafts = [];
+    for (const entry of entries) {
+        if (!isLiveMemory(entry)) {
+            if (isQuarantineScope(entry.scope))
+                excluded.quarantined++;
+            else if (entry.superseded_by || entry.kind === 'superseded')
+                excluded.superseded++;
+            else if (entry.kind === 'archived')
+                excluded.archived++;
+            continue;
+        }
+        const identity = projectIdentity(entry.origin_project);
+        let p = projectIndex.get(identity.key);
+        if (p === undefined) {
+            p = drafts.length;
+            projectIndex.set(identity.key, p);
+            drafts.push(newDraft(identity));
+        }
+        const f = memoryFacts(entry, nowMs);
+        const embedded = embeddedIds !== null && embeddedIds.has(entry.id);
+        const parsedCreated = Date.parse(entry.created);
+        const draft = drafts[p];
+        draft.members.push(facts.length);
+        draft.summary.live++;
+        draft.summary.bands[BANDS[f.band]]++;
+        draft.summary.layers[LAYERS[f.layer]]++;
+        if (entry.pinned)
+            draft.summary.pinned++;
+        if (embedded)
+            draft.summary.embedded++;
+        if (Number.isFinite(parsedCreated) && parsedCreated < draft.firstCreatedMs)
+            draft.firstCreatedMs = parsedCreated;
+        if (f.lastRetrievedDays < draft.lastDays)
+            draft.lastDays = f.lastRetrievedDays;
+        facts.push(toFact(entry, f, p, embedded, Number.isFinite(parsedCreated) ? parsedCreated : nowMs));
+    }
+    const openConflicts = countOpenConflicts(facts, drafts.map((d) => d.summary), input.openConflicts);
+    const projects = drafts.map((d) => {
+        d.summary.atRisk = d.summary.bands.atRisk;
+        d.summary.share = d.summary.live > 0 ? d.summary.atRisk / d.summary.live : 0;
+        d.summary.lastRetrievedDays = d.summary.live > 0 ? round1(d.lastDays) : null;
+        return { summary: d.summary, members: Int32Array.from(d.members), firstCreatedMs: d.firstCreatedMs };
+    });
+    const embeddedTotal = projects.reduce((sum, p) => sum + p.summary.embedded, 0);
+    return {
+        id: input.id,
+        tenantId: input.tenantId,
+        nowMs,
+        facts,
+        projects,
+        byKey: new Map(projects.map((p) => [p.summary.key, p])),
+        excluded,
+        embeddingCoverage: embeddedIds === null ? null : facts.length > 0 ? embeddedTotal / facts.length : 0,
+        openConflicts,
+        memo: { sorted: new Lru(8), filtered: new Lru(8), scatter: new Map(), overview: null },
+    };
+}
+// A conflict counts once in each project it touches, and once in the total.
+function countOpenConflicts(facts, summaries, conflicts) {
+    if (conflicts.length === 0)
+        return 0;
+    const byId = new Map();
+    facts.forEach((f, i) => byId.set(f.id, i));
+    let total = 0;
+    for (const c of conflicts) {
+        const a = byId.get(c.memory_a_id);
+        const b = byId.get(c.memory_b_id);
+        if (a === undefined || b === undefined)
+            continue;
+        total++;
+        facts[a].inConflict = true;
+        facts[b].inConflict = true;
+        for (const p of new Set([facts[a].project, facts[b].project]))
+            summaries[p].openConflicts++;
+    }
+    return total;
+}
+// Keeps ids rising between two services created in the same millisecond of one process.
+let highestIssuedId = 0;
+/** Holds one read-only connection for its commit signal (`PRAGMA data_version`) and the snapshot cache; `now` dates the strength projections, `cacheClock` ages the cache. */
+export function createSnapshotService(hippoRoot, now, cacheClock = Date.now) {
+    let db = null;
+    let cached = null;
+    // Wall clock, not `now`, so ids keep rising across server restarts and a client holding an old tab never sees a lower one.
+    let lastId = Math.max(Date.now(), highestIssuedId);
+    let lastEmbeddedIds;
+    const dataVersion = () => {
+        if (db === null) {
+            if (!fs.existsSync(getHippoDbPath(hippoRoot)))
+                return null;
+            db = openHippoDbReadOnly(hippoRoot);
+        }
+        // SAFETY: PRAGMA data_version returns one row with that single integer column.
+        const row = db.prepare('PRAGMA data_version').get();
+        return row.data_version;
+    };
+    // No database means no vectors; a store not yet on schema v52 has no table to count, so coverage is unknown.
+    const readEmbeddedIds = () => {
+        if (db === null)
+            return new Set();
+        // SAFETY: sqlite_master rows carry a text name; the query only tests presence.
+        const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memory_vectors'").get();
+        return table === undefined ? null : storedVectorIds(db);
+    };
+    const build = (tenantId, dv, nowMs) => {
+        const entries = dv === null ? [] : loadAllEntries(hippoRoot, tenantId);
+        const openConflicts = dv === null ? [] : listMemoryConflicts(hippoRoot, 'open', tenantId);
+        lastId += 1;
+        highestIssuedId = Math.max(highestIssuedId, lastId);
+        // After loadAllEntries, whose writable open has run any pending migration and legacy embeddings.json import.
+        lastEmbeddedIds = readEmbeddedIds();
+        return buildSnapshot({ id: lastId, tenantId, nowMs, entries, openConflicts, embeddedIds: lastEmbeddedIds });
+    };
+    return {
+        get(tenantId, fresh = false) {
+            const nowMs = now();
+            // A frozen eval clock (HIPPO_FAKE_NOW) would never age the cache, so reuse is timed on its own clock.
+            const wallMs = cacheClock();
+            // Read before the build, so a commit that lands during it shows on the next read.
+            const dv = dataVersion();
+            const hit = cached;
+            if (hit !== null && !fresh) {
+                const age = wallMs - hit.builtAtMs;
+                const reusable = hit.snapshot.tenantId === tenantId
+                    && (hit.dataVersion !== null || dv === null)
+                    && age < TTL_MS
+                    && (hit.dataVersion === dv || age < COALESCE_MS);
+                if (reusable)
+                    return hit.snapshot;
+            }
+            const snapshot = build(tenantId, dv, nowMs);
+            cached = { snapshot, dataVersion: dv, builtAtMs: wallMs };
+            return snapshot;
+        },
+        invalidate() {
+            cached = null;
+        },
+        currentId() {
+            return lastId;
+        },
+        embeddedIds() {
+            if (lastEmbeddedIds !== undefined)
+                return lastEmbeddedIds;
+            dataVersion();
+            return readEmbeddedIds();
+        },
+        close() {
+            if (db !== null)
+                closeHippoDb(db);
+            db = null;
+            cached = null;
+            lastEmbeddedIds = undefined;
+        },
+    };
+}
+//# sourceMappingURL=dashboard-snapshot.js.map

package/dist/dashboard-types.d.ts

@@ -0,0 +1,163 @@
+/** Wire types of the dashboard's Health view; `ui/src/types.ts` mirrors them field for field. */
+export type Layer = 'buffer' | 'episodic' | 'semantic' | 'trace';
+export type Band = 'pinned' | 'strong' | 'fading' | 'atRisk';
+export type ProjectKind = 'project' | 'global' | 'unassigned';
+/** One origin project's aggregates; `key` is `p:<name>`, `global` or `unassigned`. */
+export interface ProjectSummary {
+    key: string;
+    name: string;
+    kind: ProjectKind;
+    live: number;
+    atRisk: number;
+    share: number;
+    pinned: number;
+    embedded: number;
+    openConflicts: number;
+    lastRetrievedDays: number | null;
+    bands: Record<Band, number>;
+    layers: Record<Layer, number>;
+}
+/** One KPI card; `series` is 91 daily cumulative points, oldest first (point 0 is the base at the window start, point 90 is now) so `last - first` over any range plus one points is exact; null when hippo recorded no history. */
+export interface Kpi {
+    id: 'total' | 'projects' | 'atRiskShare' | 'openConflicts' | 'embeddingCoverage';
+    label: string;
+    value: number;
+    delta: string;
+    series: number[] | null;
+}
+export interface Overview {
+    /** Bumped on each rebuild and seeded from the wall clock, so ids keep rising across server restarts. */
+    snapshotId: number;
+    generatedAt: string;
+    total: number;
+    excluded: {
+        superseded: number;
+        archived: number;
+        quarantined: number;
+    };
+    embeddingCoverage: number | null;
+    kpis: Kpi[];
+    projects: ProjectSummary[];
+    mostAtRisk: string[];
+    mostConflicts: string[];
+}
+export interface ScatterPoints {
+    mode: 'points';
+    maxAgeDays: number;
+    points: [number, number, number, number][];
+    ids: string[];
+}
+export interface ScatterGrid {
+    mode: 'grid';
+    maxAgeDays: number;
+    cols: 64;
+    rows: 32;
+    cells: [number[], number[], number[], number[]];
+}
+export interface ProjectDetail {
+    snapshotId: number;
+    summary: ProjectSummary;
+    scatter: ScatterPoints | ScatterGrid;
+}
+export interface DecayOutlook {
+    now: [number, number, number];
+    in7d: [number, number, number];
+    in30d: [number, number, number];
+    pinned: number;
+}
+export interface MemoryRow {
+    id: string;
+    content: string;
+    truncated: boolean;
+    layer: Layer;
+    band: Band;
+    strength: number;
+    retrievals: number;
+    lastRetrievedDays: number;
+    ageDays: number;
+    confidence: string;
+    scope: string | null;
+    pinned: boolean;
+    wrong: boolean;
+    inConflict: boolean;
+}
+/** Memory counts for each chip over the filtered set. */
+export interface ChipCounts {
+    all: number;
+    risk: number;
+    pinned: number;
+    conflict: number;
+}
+export interface MemoryPage {
+    snapshotId: number;
+    total: number;
+    offset: number;
+    limit: number;
+    counts: ChipCounts;
+    decay: DecayOutlook;
+    rows: MemoryRow[];
+}
+export interface MemoryConflictDetail {
+    id: number;
+    reason: string;
+    score: number;
+    other: {
+        id: string;
+        content: string;
+        strength: number;
+        retrievals: number;
+    };
+}
+export interface MemoryDetail {
+    snapshotId: number;
+    id: string;
+    content: string;
+    layer: Layer;
+    band: Band;
+    tags: string[];
+    strength: number;
+    strength7d: number;
+    strength30d: number;
+    halfLifeDays: number;
+    retrievals: number;
+    lastRetrieved: string;
+    created: string;
+    ageDays: number;
+    schemaFit: number;
+    valence: string;
+    confidence: string;
+    agedOut: boolean;
+    pinned: boolean;
+    wrong: boolean;
+    projectKey: string;
+    projectName: string;
+    scope: string | null;
+    tenant: string;
+    kind: string;
+    embedded: boolean;
+    conflicts: MemoryConflictDetail[];
+}
+export interface SearchResult {
+    snapshotId: number;
+    q: string;
+    total: number;
+    hits: Record<string, number>;
+    nameMatches: {
+        key: string;
+        name: string;
+        live: number;
+    }[];
+}
+/** Body of `POST /api/conflicts/:id/resolve` on success. */
+export interface ResolveResult {
+    ok: true;
+    conflictId: number;
+    keptId: string;
+    weakenedId: string;
+}
+/** Body of `POST /api/memory/:id/forget` on success. */
+export interface ForgetResult {
+    ok: true;
+    id: string;
+}
+//# sourceMappingURL=dashboard-types.d.ts.map

package/dist/dashboard-types.js

@@ -0,0 +1,3 @@
+/** Wire types of the dashboard's Health view; `ui/src/types.ts` mirrors them field for field. */
+export {};
+//# sourceMappingURL=dashboard-types.js.map

package/dist/dashboard.d.ts

@@ -1,9 +1,8 @@
-/**
- * Hippo Dashboard — local web UI for memory health visualization.
- * Serves a single-page app with memory stats, decay curves, and conflict status.
- *
- * Usage: hippo dashboard [--port 3333]
- */
+/** Hippo dashboard server: the React bundle plus the JSON API behind the Health view and the Board (`hippo dashboard --port`). */
 import * as http from 'http';
-export declare function serveDashboard(hippoRoot: string, port?: number): http.Server;
+/** Serves the dashboard on 127.0.0.1 behind a per-start `token` (tests pass one), since loopback alone lets any local process read every memory; `opts` sets the projection and cache clocks. */
+export declare function serveDashboard(hippoRoot: string, port?: number, token?: string, opts?: {
+    now?: () => number;
+    cacheClock?: () => number;
+}): http.Server;
 //# sourceMappingURL=dashboard.d.ts.map