hippo-memory 1.71.0 → 1.72.0

package/dist/store/auth.d.ts

@@ -12,13 +12,15 @@ export declare function apiKeyVerifyStats(): ApiKeyVerifyStats;
 export interface CreateApiKeyOpts {
     tenantId: string;
     label?: string;
-    /** 'admin' | 'member'. Defaults to 'admin' (backward-compat for callers that don't specify). */
+    /** 'admin' | 'member'. Defaults to 'member', like the API layer. */
     role?: 'admin' | 'member';
     /** The auth-resolver subject a self-service key belongs to; unset for keys an admin or the CLI mints. */
     ownerSubject?: string;
-    /** ISO time the key stops working; unset means it never expires. */
+    /** ISO time the key stops working; unset means DEFAULT_KEY_TTL_DAYS from now. */
     expiresAt?: string;
 }
+/** Days a key lives when its mint names no expiry, so a key nobody remembers stops working by itself. */
+export declare const DEFAULT_KEY_TTL_DAYS = 90;
 export interface CreateApiKeyResult {
     keyId: string;
     plaintext: string;

package/dist/store/auth.js

@@ -3,6 +3,7 @@ import { promisify } from 'node:util';
 import { closeHippoDb, openHippoDb } from '../db/index.js';
 import { raiseMinBinary } from '../db/meta.js';
 import { keysetAfter } from '../util/keyset.js';
+import { DAY_MS } from '../util/time.js';
 import { EXPIRING_KEYS_MIN_BINARY } from '../util/version.js';
 /** Every minted API key starts with this, so the server can route a bearer token by shape. */
 export const API_KEY_PREFIX = 'hk_';
@@ -48,6 +49,8 @@ function verifyKey(plaintext, stored) {
     return parsed.matches(scryptSync(plaintext, parsed.salt, parsed.keylen));
 }
 const scryptOffLoop = promisify(scrypt);
+/** Days a key lives when its mint names no expiry, so a key nobody remembers stops working by itself. */
+export const DEFAULT_KEY_TTL_DAYS = 90;
 export function mintApiKey() {
     const keyId = `${API_KEY_PREFIX}${randBase32(ID_LEN)}`;
     const plaintext = `${keyId}.${randBase32(SECRET_LEN)}`;
@@ -63,8 +66,8 @@ export function insertApiKey(db, key) {
 export function createApiKey(db, opts) {
     const { keyId, plaintext, keyHash } = mintApiKey();
     insertApiKey(db, {
-        keyId, keyHash, tenantId: opts.tenantId, label: opts.label ?? null, role: opts.role ?? 'admin', createdAt: new Date().toISOString(),
-        ownerSubject: opts.ownerSubject ?? null, expiresAt: opts.expiresAt ?? null,
+        keyId, keyHash, tenantId: opts.tenantId, label: opts.label ?? null, role: opts.role ?? 'member', createdAt: new Date().toISOString(),
+        ownerSubject: opts.ownerSubject ?? null, expiresAt: opts.expiresAt ?? new Date(Date.now() + DEFAULT_KEY_TTL_DAYS * DAY_MS).toISOString(),
     });
     return { keyId, plaintext };
 }
@@ -251,7 +254,8 @@ export function listApiKeyRows(db, opts) {
     const limitSql = opts.limit === undefined ? '' : ' LIMIT ?';
     if (opts.limit !== undefined)
         params.push(opts.limit);
-    const sql = `SELECT id, key_id, tenant_id, label, created_at, revoked_at, role, expires_at, owner_subject FROM api_keys WHERE ${where.join(' AND ')}${after.sql} ORDER BY id DESC${limitSql}`;
+    const sql = `SELECT id, key_id, tenant_id, label, created_at, revoked_at, role, expires_at, owner_subject FROM api_keys ` +
+        `WHERE ${where.join(' AND ')}${after.sql} ORDER BY id DESC${limitSql}`;
     // SAFETY: the SELECT above projects exactly these 9 columns, in this order.
     const rows = db.prepare(sql).all(...params);
     return rows.map(r => ({

package/dist/store/candidates.d.ts

@@ -1,5 +1,5 @@
 import { type MemoryEntry, type ConfidenceLevel, Layer } from '../core/memory.js';
-import { type SqlFragment } from './recall-scope.js';
+import { type SqlFragment } from './rule-sql.js';
 export interface AmbientRecallRequest {
     terms: string[];
     limit: number;
@@ -37,7 +37,8 @@ export declare const EVERY_SCOPE: SqlFragment;
 export declare function loadTextsHoldingWords(hippoRoot: string, tenantId: string | undefined, words: readonly string[], project?: readonly string[], admit?: SqlFragment): HeldText[];
 /** A tenant's `limit` newest rows, oldest first: the tail of loadAllEntries' order, without reading the rows before it. */
 export declare function loadNewestEntries(hippoRoot: string, tenantId: string, limit: number): MemoryEntry[];
-/** computeSchemaFit against every row of a tenant: tag counts come from one aggregate and texts stream one column, so no row is loaded. */
+/** computeSchemaFit against a tenant's newest SCHEMA_FIT_WINDOW_ROWS rows: tag counts come from one aggregate
+ * and texts stream one column, so no row is loaded. */
 export declare function schemaFitInStore(hippoRoot: string, tenantId: string, content: string, tags: readonly string[]): number;
 export interface SourceTally {
     source: string;

package/dist/store/candidates.js

@@ -1,7 +1,7 @@
 import { FALLBACK_HALF_LIFE_DAYS, Layer, calculateStrength, facetsOf, schemaFitFrom } from '../core/memory.js';
 import { strengthSql } from './rule-sql.js';
 import { withReadSnapshot } from '../db/index.js';
-import { scopeAdmitSql } from './recall-scope.js';
+import { scopeAdmitSql } from './rule-sql.js';
 import { MEMORY_SELECT_COLUMNS, rowToEntry, parseJsonArray } from './rows.js';
 import { onHandle, openStore } from './open.js';
 import { originInSql } from '../core/project-identity.js';
@@ -15,32 +15,44 @@ function inOrigins(e, origins) {
     const origin = e.origin_project ?? null;
     return origin === '' ? origins.userGlobal : origin !== null && origins.names.includes(origin);
 }
+// `id DESC` mirrors getContext's comparator, not loadFreshRawMemories'
+// cross-ingest-stable order: that would change what the hook injects.
+const NEWEST = 'ORDER BY created DESC, id DESC';
 // The newest rows `admit` keeps, newest first. The first window stays unfiltered so admit still sees, and the
 // delivery ledger still counts, the other-project rows it refuses; past it, the reads narrow to the caller's origins.
 function loadRecentRows(run, drifted, tenantId, options) {
     const { needed, admit, origins } = options;
     const keep = origins ? (e) => admit(e) && inOrigins(e, origins) : admit;
-    // `id DESC` mirrors getContext's comparator, not loadFreshRawMemories'
-    // cross-ingest-stable order: that would change what the hook injects.
-    const newest = 'ORDER BY created DESC, id DESC';
     const window = Math.max(needed * 4, 32);
     const originSql = origins && (origins.userGlobal ? `(origin_project = '' OR ${originInSql(origins.names)})` : originInSql(origins.names));
-    const ownWhere = originSql ? `${AMBIENT_SCOPED} AND ${originSql}` : AMBIENT_SCOPED;
-    const ownParams = [tenantId, ...(origins?.names ?? [])];
-    if (!drifted) {
-        const windowed = run(`${AMBIENT_SCOPED} ${newest} LIMIT ?`, [tenantId, window]);
-        const kept = windowed.filter(keep);
-        if (kept.length >= needed || windowed.length < window)
+    const own = { where: originSql ? `${AMBIENT_SCOPED} AND ${originSql}` : AMBIENT_SCOPED, params: [tenantId, ...(origins?.names ?? [])] };
+    // Text order is chronological only for standard UTC ISO (memory.ts), so a drifted store is read whole and re-sorted downstream.
+    if (drifted)
+        return run(`${own.where} ${NEWEST}`, [...own.params]).filter(keep);
+    let read = run(`${AMBIENT_SCOPED} ${NEWEST} LIMIT ?`, [tenantId, window]);
+    let kept = read.filter(keep);
+    if (kept.length >= needed || read.length < window)
+        return kept;
+    if (origins) {
+        read = run(`${own.where} ${NEWEST} LIMIT ?`, [...own.params, window]);
+        kept = read.filter(keep);
+        if (kept.length >= needed || read.length < window)
             return kept;
-        if (origins) {
-            const ownWindow = run(`${ownWhere} ${newest} LIMIT ?`, [...ownParams, window]);
-            const ownKept = ownWindow.filter(keep);
-            if (ownKept.length >= needed || ownWindow.length < window)
-                return ownKept;
-        }
     }
-    // Text order is chronological only for standard UTC ISO (memory.ts), and a window of junk can hide older rows.
-    return run(`${ownWhere} ${newest}`, ownParams).filter(keep);
+    return [...kept, ...keptPastWindow(run, own, read, needed - kept.length, keep)];
+}
+// A window of refused rows can hide older ones, so read on in keyset pages, each four times the last, until enough are kept.
+function keptPastWindow(run, own, read, wanted, keep) {
+    const out = [];
+    let last = read[read.length - 1];
+    for (let size = read.length * 4; out.length < wanted; size *= 4) {
+        const page = run(`${own.where} AND created <= ? AND (created < ? OR id < ?) ${NEWEST} LIMIT ?`, [...own.params, last.created, last.created, last.id, size]);
+        out.push(...page.filter(keep));
+        if (page.length < size)
+            break;
+        last = page[page.length - 1];
+    }
+    return out;
 }
 // The pins plus the `recentNeeded` newest rows that pass `admit`, for ambient injection. One connection;
 // `recall` piggybacks the prompt-recall FTS query on it too. `origins` narrows the recent rows past the first window.
@@ -124,7 +136,8 @@ export function loadTextsHoldingWords(hippoRoot, tenantId, words, project, admit
         for (let i = 0; i < unique.length; i += 200) {
             const chunk = unique.slice(i, i + 200);
             // SAFETY: rows' shape matches the three columns named in the SELECT below.
-            const rows = db.prepare(`SELECT content, source, origin_project FROM memories WHERE ${tenantWhere}${originWhere} AND ${admit.sql} AND (${chunk.map(() => 'instr(content, ?) > 0').join(' OR ')})`).all(...tenantParams, ...(project ?? []), ...admit.params, ...chunk);
+            const rows = db.prepare(`SELECT content, source, origin_project FROM memories WHERE ${tenantWhere}${originWhere} AND ${admit.sql} AND (${chunk.map(() => 'instr(content, ?) ' +
+                '> 0').join(' OR ')})`).all(...tenantParams, ...(project ?? []), ...admit.params, ...chunk);
             for (const row of rows)
                 out.push({ content: row.content, source: row.source ?? 'cli', origin_project: row.origin_project });
         }
@@ -143,13 +156,17 @@ function* contentsOf(rows) {
     for (const row of rows)
         yield row.content;
 }
-/** computeSchemaFit against every row of a tenant: tag counts come from one aggregate and texts stream one column, so no row is loaded. */
+/** How many of a tenant's newest rows schemaFitInStore reads; older rows no longer move the fit. */
+const SCHEMA_FIT_WINDOW_ROWS = 2000;
+/** computeSchemaFit against a tenant's newest SCHEMA_FIT_WINDOW_ROWS rows: tag counts come from one aggregate
+ * and texts stream one column, so no row is loaded. */
 export function schemaFitInStore(hippoRoot, tenantId, content, tags) {
+    const newest = 'SELECT tags_json, content FROM memories WHERE tenant_id = ? ORDER BY created DESC, id DESC LIMIT ?';
     return onHandle(hippoRoot, (db) => {
         // One read transaction, so the row count and the texts come from the same snapshot.
         return withReadSnapshot(db, () => {
             // SAFETY: rows' shape matches the two columns named in the SELECT.
-            const groups = db.prepare('SELECT tags_json, COUNT(*) AS n FROM memories WHERE tenant_id = ? GROUP BY tags_json').all(tenantId);
+            const groups = db.prepare(`SELECT tags_json, COUNT(*) AS n FROM (${newest}) GROUP BY tags_json`).all(tenantId, SCHEMA_FIT_WINDOW_ROWS);
             let rows = 0;
             const tagCounts = new Map();
             for (const group of groups) {
@@ -157,9 +174,11 @@ export function schemaFitInStore(hippoRoot, tenantId, content, tags) {
                 for (const tag of parseJsonArray(group.tags_json))
                     tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + group.n);
             }
-            // SHORTCUT: the text walk visits rows until a tenth of the tenant matches; a stored token count per tenant is the upgrade.
+            // SHORTCUT: only the newest SCHEMA_FIT_WINDOW_ROWS rows count, so older tags drop out;
+            // a stored per-tenant tag and token tally is the upgrade.
             // SAFETY: the SELECT names exactly the one column read.
-            const texts = db.prepare('SELECT content FROM memories WHERE tenant_id = ?').iterate(tenantId);
+            const texts = db.prepare(`SELECT content FROM (${newest})`)
+                .iterate(tenantId, SCHEMA_FIT_WINDOW_ROWS);
             return schemaFitFrom(content, tags, { rows, tagCounts, contents: contentsOf(texts) });
         });
     }, openStore);

package/dist/store/capture-write.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryEntry } from '../core/memory.js';
+export type CapturedOutcome = 'captured' | 'skipped' | 'rejected';
+export interface CaptureItem {
+    readonly content: string;
+    /** Built only for an item that is not a repeat of an earlier one, since building can throw. */
+    readonly makeEntry: () => MemoryEntry;
+}
+export interface CaptureWriteOpts {
+    readonly actor?: string;
+    /** No stats, as in a server process. */
+    readonly lean: boolean;
+    /** Called with each captured entry after its write, so the caller can embed it; the store never picks a provider. */
+    readonly onCaptured?: (entry: MemoryEntry) => void;
+}
+/** One outcome per item, in order. `keys` holds the texts already stored and gains each one written, so a repeat inside the batch is skipped. */
+export declare function writeCapturedItems(hippoRoot: string, items: readonly CaptureItem[], keys: Set<string>, opts: CaptureWriteOpts): CapturedOutcome[];
+//# sourceMappingURL=capture-write.d.ts.map

package/dist/store/capture-write.js

@@ -0,0 +1,35 @@
+import { closeHippoDb } from '../db/index.js';
+import { duplicateKey } from '../util/same-text.js';
+import { writeEntryMirrors } from './entry-writes.js';
+import { stampOriginProject } from './entry-row.js';
+import { gatedWrite } from './gated-write.js';
+import { updateStatsOn } from './index-and-stats.js';
+import { openStore } from './open.js';
+/** One outcome per item, in order. `keys` holds the texts already stored and gains each one written, so a repeat inside the batch is skipped. */
+export function writeCapturedItems(hippoRoot, items, keys, opts) {
+    const db = openStore(hippoRoot);
+    try {
+        return items.map((item) => {
+            if (keys.has(duplicateKey(item.content)))
+                return 'skipped';
+            const entry = item.makeEntry();
+            // One rejected item must not abort the rest of this capture's items.
+            const stamped = stampOriginProject(hippoRoot, entry);
+            const outcome = gatedWrite(db, hippoRoot, stamped, { actor: opts.actor });
+            if (outcome === 'skipped:rejected')
+                return 'rejected';
+            if (outcome !== 'written')
+                return 'skipped';
+            writeEntryMirrors(hippoRoot, stamped);
+            if (!opts.lean)
+                updateStatsOn(db, hippoRoot, { remembered: 1 });
+            keys.add(duplicateKey(item.content)); // within-batch dedup
+            opts.onCaptured?.(entry);
+            return 'captured';
+        });
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+//# sourceMappingURL=capture-write.js.map

package/dist/store/cards.js

@@ -4,7 +4,7 @@ import { rowToSessionHandoff, isHandoffOutcome } from '../core/handoff.js';
 import { CARD_LEASE_MS, assertCardTransition } from '../core/card.js';
 import { assertTenantId } from './tenant.js';
 import { onHandle, openStore } from './open.js';
-import { chunked } from './entry-reads.js';
+import { chunked } from '../util/chunked.js';
 import { HANDOFF_COLUMNS } from './handoffs.js';
 const CARD_COLUMNS = 'id, title, status, assignee_runtime, repo, contract, budget, lease_until, heartbeat_at, created_at, updated_at, tenant_id, scope';
 function rowToCard(row) {

package/dist/store/compaction-caller.d.ts

@@ -0,0 +1,18 @@
+import { type CompactionStart, type Log } from './compactions-record.js';
+/** {@link startCompaction} on a handle of its own, for a caller's request. */
+export declare function startCompactionAt(hippoRoot: string, tenantId: string, start: CompactionStart): string;
+/** {@link markSnapshotSaved} on a handle of its own, for a caller's request. */
+export declare function markSnapshotSavedAt(hippoRoot: string, tenantId: string, recordId: string): void;
+export interface CallerItems {
+    readonly sessionId: string;
+    readonly trigger: string | null;
+    readonly requestId: string;
+    readonly project: string;
+    readonly items: readonly string[];
+    /** The caller's audit actor and its project's names. */
+    readonly owner: string;
+    readonly origins: readonly string[];
+}
+/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count, and a `summarised` one is reused. */
+export declare function saveCallerItems(hippoRoot: string, tenantId: string, req: CallerItems, log: Log): number;
+//# sourceMappingURL=compaction-caller.d.ts.map

package/dist/store/compaction-caller.js

@@ -0,0 +1,29 @@
+// A caller's compaction calls on a handle of its own, for code that has a folder and no connection.
+import { onHandle } from './open.js';
+import { compactionByRequest, markSnapshotSaved, recordSummary, saveItems, startCompaction, } from './compactions-record.js';
+/** {@link startCompaction} on a handle of its own, for a caller's request. */
+export function startCompactionAt(hippoRoot, tenantId, start) {
+    return onHandle(hippoRoot, (db) => startCompaction(db, tenantId, start));
+}
+/** {@link markSnapshotSaved} on a handle of its own, for a caller's request. */
+export function markSnapshotSavedAt(hippoRoot, tenantId, recordId) {
+    onHandle(hippoRoot, (db) => markSnapshotSaved(db, tenantId, recordId));
+}
+/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count, and a `summarised` one is reused. */
+export function saveCallerItems(hippoRoot, tenantId, req, log) {
+    return onHandle(hippoRoot, (db) => {
+        const earlier = compactionByRequest(db, tenantId, req.requestId, req.sessionId);
+        if (earlier !== null && earlier.status !== 'summarised')
+            return earlier.itemsWritten;
+        const meta = { sessionId: req.sessionId, trigger: req.trigger, cwd: null, transcriptPath: null };
+        const text = { summary: '', items: [...req.items] };
+        const record = earlier ?? recordSummary(db, hippoRoot, tenantId, {
+            meta, text, at: new Date(), caller: { originProject: req.project, requestId: req.requestId },
+        });
+        return saveItems(db, hippoRoot, {
+            tenantId, recordId: record.id, sessionId: req.sessionId, originProject: record.originProject, cwd: null,
+            items: record.items, caller: { actor: req.owner, origins: req.origins },
+        }, log);
+    });
+}
+//# sourceMappingURL=compaction-caller.js.map

package/dist/store/compactions-record.d.ts

@@ -0,0 +1,115 @@
+import { type DatabaseSyncLike } from '../db/index.js';
+import { type CompactionStatus } from './compactions.js';
+export type { CompactionStatus };
+export interface CompactionRecord {
+    id: string;
+    tenantId: string;
+    sessionId: string;
+    originProject: string;
+    trigger: string | null;
+    cwd: string | null;
+    transcriptPath: string | null;
+    snapshotSaved: boolean;
+    startedAt: string;
+    summarisedAt: string | null;
+    summary: string | null;
+    items: string[];
+    itemsWritten: number;
+    status: CompactionStatus;
+}
+export type Log = (message: string) => void;
+export interface CompactionStart {
+    sessionId: string;
+    originProject: string;
+    trigger: string | null;
+    cwd: string | null;
+    transcriptPath: string | null;
+}
+export declare function startCompaction(db: DatabaseSyncLike, tenantId: string, start: CompactionStart, at?: Date): string;
+/** A session's newest record, or null. */
+export declare function latestCompaction(db: DatabaseSyncLike, tenantId: string, sessionId: string): CompactionRecord | null;
+/** The record a caller's request made, whatever state it reached, so a retry neither writes its items twice nor starts a second record.
+ * Another session's id is a ConflictError. */
+export declare function compactionByRequest(db: DatabaseSyncLike, tenantId: string, requestId: string, sessionId: string): CompactionRecord | null;
+/** Best effort, never throws: a compaction must not fail because its record could not be written. */
+export declare function recordCompactionStart(hippoRoot: string, start: Omit<CompactionStart, 'originProject'>, log: Log): string | null;
+/** On the caller's handle and tenant, so a server marks the record under the caller's tenant with its own wait. */
+export declare function markSnapshotSaved(db: DatabaseSyncLike, tenantId: string, recordId: string): void;
+export declare function recordSnapshotSaved(hippoRoot: string, tenantId: string, recordId: string, log: Log): void;
+export interface CompactionText {
+    summary: string;
+    items: string[];
+}
+/** A caller's checked project, and the id its retries carry so a retry finds this record. */
+export interface SummaryCaller {
+    originProject?: string;
+    requestId?: string;
+}
+export interface RecordSummaryOptions {
+    readonly meta: Omit<CompactionStart, 'originProject'>;
+    readonly text: CompactionText;
+    readonly at: Date;
+    readonly caller?: SummaryCaller;
+}
+/** Puts the summary on the session's `started` record, or inserts a `summarised` one when pre-compact wrote none. One statement each. */
+export declare function recordSummary(db: DatabaseSyncLike, hippoRoot: string, tenantId: string, options: RecordSummaryOptions): CompactionRecord;
+export interface ItemContext {
+    tenantId: string;
+    /** null when the record step failed: the items still go in, with no record to close. */
+    recordId: string | null;
+    sessionId: string;
+    originProject: string;
+    /** Where the session ran, so rows held under the project's older folder name count too. */
+    cwd: string | null;
+    items: string[];
+    /** Set when another machine sent the items: its audit actor and its project's names, since the server's folder is neither. */
+    caller?: {
+        actor: string;
+        origins: readonly string[];
+    };
+}
+/** Items that become rows, then the record `done`, in one transaction so two sessions cannot both insert one text. Mirrors after commit. */
+export declare function saveItems(db: DatabaseSyncLike, hippoRoot: string, ctx: ItemContext, log: Log): number;
+export interface CompactionSaveResult {
+    /** Memories written; null when neither the record nor the items could be saved. */
+    written: number | null;
+    /** True when the rest waits for the next sleep or post-compact. */
+    deferred: boolean;
+    snapshotSaved: boolean;
+}
+/** What one PostCompact save did; `spoolReason` is set when the store was busy or would not open, so the caller keeps the summary on disk. */
+export interface CompactionSaveOutcome {
+    result: CompactionSaveResult;
+    spoolReason: string | null;
+}
+/** The PostCompact store work, on a handle of its own: record the summary, then write its items. Each step is independent. Never throws. */
+export declare function saveCompactionAt(hippoRoot: string, meta: Omit<CompactionStart, 'originProject'>, text: CompactionText, at: Date, log: Log): CompactionSaveOutcome;
+/** One spooled summary, as plain data. */
+export interface SpooledSummary {
+    tenantId: string;
+    payload: Omit<CompactionStart, 'originProject'>;
+    text: CompactionText;
+    at: Date;
+}
+/** Records one spooled summary; it calls `recorded` once the store holds it, so the file is done even if a later step throws. */
+export type SpoolRecorder = (spooled: SpooledSummary, recorded: () => void) => void;
+/** A summary read out of a transcript, scrubbed; `listed` is false when it had no memories section. */
+export interface TranscriptText {
+    text: CompactionText;
+    listed: boolean;
+}
+/** The file work a replay needs, handed in by the caller so the store holds none of it. */
+export interface ReplaySources {
+    /** Feeds each spooled summary to `record`; returns how many it imported. */
+    importSpool(tenantId: string, deadline: number, record: SpoolRecorder): number;
+    transcriptExists(transcriptPath: string): boolean;
+    /** The summary a transcript holds between two moments, or null when it is not (yet) there. */
+    transcriptText(transcriptPath: string, afterMs: number, beforeMs: number): TranscriptText | null;
+}
+export interface ReplayOptions {
+    busyWaitMs?: number;
+    deadline?: number;
+}
+/** For `hippo sleep` and post-compact: opens the store itself and never throws. */
+export declare function replayStoredCompactions(hippoRoot: string, sources: ReplaySources, log: Log, opts?: ReplayOptions): number;
+//# sourceMappingURL=compactions-record.d.ts.map