hippo-memory 1.72.0 → 2.1.0

package/dist/util/http-util.js

@@ -11,7 +11,8 @@ export const MAX_BODY_BYTES = 1024 * 1024;
 function sizeLabel(bytes) {
     return bytes % (1024 * 1024) === 0 ? `${bytes / (1024 * 1024)}MB` : `${Math.ceil(bytes / 1024)}KB`;
 }
-// How long a refused upload is still read and discarded after its reply, so a client that never stops cannot hold the socket.
+// How long a refused upload is still read and discarded after its reply, so a client that never stops cannot hold the
+// socket.
 const REFUSED_UPLOAD_LINGER_MS = 2000;
 export const JSON_HEADERS = { 'content-type': 'application/json' };
 export class HttpError extends Error {
@@ -24,7 +25,10 @@ export class HttpError extends Error {
         this.retryAfterSec = retryAfterSec;
     }
 }
-/** A request, or a store call it waited on, ran past the request's deadline; the reply carries `code` so a client branches without parsing prose. */
+/**
+ * A request, or a store call it waited on, ran past the request's deadline; the reply carries `code` so a client
+ * branches without parsing prose.
+ */
 export class DeadlineExceededError extends HttpError {
     code = 'deadline_exceeded';
     constructor(message) {
@@ -48,11 +52,17 @@ export function sendJson(res, status, body) {
     res.end(text);
 }
 const DEFAULT_BODY_DEADLINE_MS = 30_000;
-/** How long any route waits for a request body, so a client that sends headers and then stalls cannot hold a request open: 30 s, or HIPPO_BODY_TIMEOUT_MS. */
+/**
+ * How long any route waits for a request body, so a client that sends headers and then stalls cannot hold a request
+ * open: 30 s, or HIPPO_BODY_TIMEOUT_MS.
+ */
 export function bodyDeadlineMs() {
     return envBodyTimeoutMs() ?? DEFAULT_BODY_DEADLINE_MS;
 }
-/** The body as text, refused mid-stream past maxBytes and past deadlineMs, so an oversized or slow sender cannot tie up the server. */
+/**
+ * The body as text, refused mid-stream past maxBytes and past deadlineMs, so an oversized or slow sender cannot tie up
+ * the server.
+ */
 export function readBody(req, { maxBytes = MAX_BODY_BYTES, deadlineMs = bodyDeadlineMs() } = {}) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -63,7 +73,8 @@ export function readBody(req, { maxBytes = MAX_BODY_BYTES, deadlineMs = bodyDead
             chunks.length = 0;
             reject(err);
         };
-        // Not for-await: leaving that loop early destroys the request, so the socket stops reading and the 413 caller cannot close it cleanly.
+        // Not for-await: leaving that loop early destroys the request, so the socket stops reading and the 413 caller
+        // cannot close it cleanly.
         const onData = (chunk) => {
             total += chunk.length;
             if (total <= maxBytes) {
@@ -84,7 +95,8 @@ export function readBody(req, { maxBytes = MAX_BODY_BYTES, deadlineMs = bodyDead
         });
     });
 }
-// A full close with request bytes unread sends a TCP reset, which discards the reply before the client reads it (RFC 9112 9.6).
+// A full close with request bytes unread sends a TCP reset, which discards the reply before the client reads it (RFC
+// 9112 9.6).
 export function closeAfterReply(req) {
     const socket = req.socket;
     req.resume();
@@ -112,16 +124,23 @@ function originHost(origin) {
         return null;
     }
 }
-// A webhook route takes no key, so anyone holding a signature header could otherwise keep a socket open with a body that never ends.
+// A webhook route takes no key, so anyone holding a signature header could otherwise keep a socket open with a body
+// that never ends.
 const WEBHOOK_BODY_DEADLINE_MS = 10_000;
-/** Call before refusing a webhook unread: a caller still sending its body loses the socket once the reply is out, as it does after a 413. */
+/**
+ * Call before refusing a webhook unread: a caller still sending its body loses the socket once the reply is out, as it
+ * does after a 413.
+ */
 export function closeIfBodyUnread({ req, res }) {
     res.once('finish', () => {
         if (!req.complete)
             closeAfterReply(req);
     });
 }
-/** A webhook's raw body, exactly as sent, for the receiver's HMAC check; call it only once a secret is configured and the signature headers are present. */
+/**
+ * A webhook's raw body, exactly as sent, for the receiver's HMAC check; call it only once a secret is configured and
+ * the signature headers are present.
+ */
 export function readWebhookBody({ req, opts }) {
     return readBody(req, { deadlineMs: opts.webhookBodyDeadlineMs ?? WEBHOOK_BODY_DEADLINE_MS });
 }

package/dist/util/json.d.ts

@@ -12,6 +12,9 @@ export declare function isJsonObject(value: JsonValue | undefined): value is {
 export declare function isJsonObjectLiteral(value: JsonValue | undefined): value is {
     [key: string]: JsonValue;
 };
-/** Windows PowerShell 5.1 saves JSON with a UTF-8 byte order mark that JSON.parse rejects, so one leading mark is dropped. */
+/**
+ * Windows PowerShell 5.1 saves JSON with a UTF-8 byte order mark that JSON.parse rejects, so one leading mark is
+ * dropped.
+ */
 export declare function readJsonFile(file: string): JsonValue;
 //# sourceMappingURL=json.d.ts.map

package/dist/util/json.js

@@ -17,7 +17,10 @@ export function isJsonObject(value) {
 export function isJsonObjectLiteral(value) {
     return value !== undefined && value !== null && !Array.isArray(value) && value.constructor === Object;
 }
-/** Windows PowerShell 5.1 saves JSON with a UTF-8 byte order mark that JSON.parse rejects, so one leading mark is dropped. */
+/**
+ * Windows PowerShell 5.1 saves JSON with a UTF-8 byte order mark that JSON.parse rejects, so one leading mark is
+ * dropped.
+ */
 export function readJsonFile(file) {
     const text = fs.readFileSync(file, 'utf8');
     return JSON.parse(text.codePointAt(0) === 0xfeff ? text.slice(1) : text);

package/dist/util/keyset.js

@@ -1,4 +1,5 @@
-// Keyset paging for list queries ordered by (sort key DESC, id DESC), so a page never skips or repeats a row when rows arrive between requests.
+// Keyset paging for list queries ordered by (sort key DESC, id DESC), so a page never skips or repeats a row when rows
+// arrive between requests.
 /** An ` AND ...` WHERE fragment and its params selecting rows strictly after `after`; empty when `after` is unset. */
 export function keysetAfter(sortCol, idCol, after) {
     if (!after)

package/dist/util/limits.js

@@ -1,8 +1,10 @@
-// Cap for id-shaped request fields (ids, tenant, session, scope, class): far above real values, small enough to bound logs and indexes.
+// Cap for id-shaped request fields (ids, tenant, session, scope, class): far above real values, small enough to bound
+// logs and indexes.
 export const MAX_ID_LEN = 256;
 // Page size every list surface (CLI, HTTP, store) falls back to when the caller names none.
 export const DEFAULT_LIST_LIMIT = 100;
-// Ceiling for a caller-named list page; SQLite `LIMIT ?` and one response's size bound it, and every list surface shares it.
+// Ceiling for a caller-named list page; SQLite `LIMIT ?` and one response's size bound it, and every list surface
+// shares it.
 export const MAX_LIST_LIMIT = 1000;
 /** The one list-limit rule: absent means the default; a positive integer up to the ceiling passes.
  * Anything else returns undefined, so each surface words its own error. */

package/dist/util/log.d.ts

@@ -1,7 +1,8 @@
 /** Leveled stderr logger. `HIPPO_LOG` picks the threshold (error, warn, info,
  * debug); unset or unknown means warn. `HIPPO_LOG_FORMAT=json` writes JSON lines. */
 export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
-/** Extra key=value pairs appended to the line. `ts` and, inside a request, `requestId` are added to every line written. */
+/** Extra key=value pairs appended to the line. `ts` and, inside a request, `requestId` are added to every line
+ * written. */
 export interface LogFields {
     ts?: string;
     requestId?: string;
@@ -14,10 +15,15 @@ export declare function isLevelEnabled(level: LogLevel): boolean;
 export declare function formatLogLine(level: LogLevel, message: string, fields?: LogFields): string;
 /** One JSON object per line for a log collector; JSON escaping keeps a multi-line value on the one line. */
 export declare function formatLogJson(level: LogLevel, message: string, fields?: LogFields): string;
-/** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. Past the key cap an unseen key logs at debug. */
+/** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. Past the key
+ * cap an unseen key logs at debug. */
 declare function once(key: string, level: LogLevel, message: string, fields?: LogFields): void;
-/** Warn the first time `key` is seen in this process, then log at debug, so a repeating failure stays findable without flooding stderr. */
+/** Warn the first time `key` is seen in this process, then log at debug, so a repeating failure stays findable
+ * without flooding stderr. */
 declare function warnThenDebug(key: string, message: string, fields?: LogFields): void;
+/** Warn the first time `key` is seen, then count repeats at debug and warn again with the running count on every
+ * 100th, so a failure that keeps happening stays visible without flooding stderr. */
+declare function warnThenSample(key: string, message: string, fields?: LogFields): void;
 /** The class name and stack of a thrown value, as log fields; a non-Error throw has no stack. */
 export declare function errorFields<E>(err: E): LogFields;
 export declare const log: {
@@ -27,11 +33,13 @@ export declare const log: {
     readonly debug: (message: string, fields?: LogFields) => void;
     readonly once: typeof once;
     readonly warnThenDebug: typeof warnThenDebug;
+    readonly warnThenSample: typeof warnThenSample;
 };
-/** Message for a caught value of unknown shape. `cause` names the sanctioned unknown-input case (error-cause enrichment). */
+/** Message for a caught value of unknown shape. `cause` names the sanctioned unknown-input case (error-cause
+ * enrichment). */
 export declare function errorMessage(cause: unknown): string;
 /** One post-compact failure, told once to the hook's output (`say`) and once to the structured log. */
-export declare function reportCompactionFailure(say: (message: string) => void, step: string, reason: string): void;
+export declare function reportCompactionFailure(say: (message: string) => void, step: string, reason: string, fields?: LogFields): void;
 /** The string `code` of a caught value (an errno name such as EACCES), or '' when it has none. */
 export declare function errorCode(cause: unknown): string;
 /** Test hook: forget which once-keys have fired. */

package/dist/util/log.js

@@ -41,7 +41,8 @@ function write(level, message, fields) {
 const ONCE_KEY_CAP = 1_000;
 const onceKeys = new Set();
 let onceCapReported = false;
-/** 'new' records the key and 'seen' is a repeat. 'uncounted' is an unseen key once the set is full: it is not recorded, and the first one says so at warn. */
+/** 'new' records the key and 'seen' is a repeat. 'uncounted' is an unseen key once the set is full: it is not
+ * recorded, and the first one says so at warn. */
 function sightOnceKey(key) {
     if (onceKeys.has(key))
         return 'seen';
@@ -55,16 +56,35 @@ function sightOnceKey(key) {
     }
     return 'uncounted';
 }
-/** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. Past the key cap an unseen key logs at debug. */
+/** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. Past the key
+ * cap an unseen key logs at debug. */
 function once(key, level, message, fields) {
     const sighting = sightOnceKey(key);
     if (sighting !== 'seen')
         write(sighting === 'new' ? level : 'debug', message, fields);
 }
-/** Warn the first time `key` is seen in this process, then log at debug, so a repeating failure stays findable without flooding stderr. */
+/** Warn the first time `key` is seen in this process, then log at debug, so a repeating failure stays findable
+ * without flooding stderr. */
 function warnThenDebug(key, message, fields) {
     write(sightOnceKey(key) === 'new' ? 'warn' : 'debug', message, fields);
 }
+const SAMPLE_EVERY = 100;
+const repeatCounts = new Map();
+/** Warn the first time `key` is seen, then count repeats at debug and warn again with the running count on every
+ * 100th, so a failure that keeps happening stays visible without flooding stderr. */
+function warnThenSample(key, message, fields) {
+    if (sightOnceKey(key) === 'new') {
+        write('warn', message, fields);
+        return;
+    }
+    // Counts only keys sightOnceKey recorded, so the map is bounded by ONCE_KEY_CAP.
+    const seen = (repeatCounts.get(key) ?? 0) + 1;
+    repeatCounts.set(key, seen);
+    if (seen % SAMPLE_EVERY === 0)
+        write('warn', `${message} (${seen} more since the first warning)`, fields);
+    else
+        write('debug', message, fields);
+}
 /** The class name and stack of a thrown value, as log fields; a non-Error throw has no stack. */
 export function errorFields(err) {
     if (!(err instanceof Error))
@@ -78,15 +98,17 @@ export const log = {
     debug: (message, fields) => write('debug', message, fields),
     once,
     warnThenDebug,
+    warnThenSample,
 };
-/** Message for a caught value of unknown shape. `cause` names the sanctioned unknown-input case (error-cause enrichment). */
+/** Message for a caught value of unknown shape. `cause` names the sanctioned unknown-input case (error-cause
+ * enrichment). */
 export function errorMessage(cause) {
     return cause instanceof Error ? cause.message : String(cause);
 }
 /** One post-compact failure, told once to the hook's output (`say`) and once to the structured log. */
-export function reportCompactionFailure(say, step, reason) {
+export function reportCompactionFailure(say, step, reason, fields) {
     say(`${step} failed: ${reason}`);
-    log.error(`post-compact: ${step} failed: ${reason}`);
+    log.error(`post-compact: ${step} failed: ${reason}`, fields);
 }
 /** The string `code` of a caught value (an errno name such as EACCES), or '' when it has none. */
 export function errorCode(cause) {
@@ -95,6 +117,7 @@ export function errorCode(cause) {
 /** Test hook: forget which once-keys have fired. */
 export function resetLogOnce() {
     onceKeys.clear();
+    repeatCounts.clear();
     onceCapReported = false;
 }
 //# sourceMappingURL=log.js.map

package/dist/util/net.d.ts

@@ -0,0 +1,5 @@
+/** A URL hostname that stays on this machine: localhost, ::1 (bracketed or not) or any 127.0.0.0/8 address. */
+export declare function isLoopbackHost(hostname: string): boolean;
+/** A socket remote address on this machine; Node reports a dual-stack IPv4 peer as '::ffff:127.x.x.x'. */
+export declare function isLoopbackAddress(remoteAddress: string | undefined): boolean;
+//# sourceMappingURL=net.d.ts.map

package/dist/util/net.js

@@ -0,0 +1,19 @@
+// Two loopback rules for two inputs: a URL hostname and a socket's remote address.
+const IPV4_LOOPBACK = /^127(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3}$/;
+const MAPPED_PREFIX = '::ffff:';
+/** A URL hostname that stays on this machine: localhost, ::1 (bracketed or not) or any 127.0.0.0/8 address. */
+export function isLoopbackHost(hostname) {
+    return hostname === 'localhost' || hostname === '[::1]' || hostname === '::1' || IPV4_LOOPBACK.test(hostname);
+}
+/** A socket remote address on this machine; Node reports a dual-stack IPv4 peer as '::ffff:127.x.x.x'. */
+export function isLoopbackAddress(remoteAddress) {
+    if (!remoteAddress)
+        return false;
+    if (remoteAddress === '::1')
+        return true;
+    const plain = remoteAddress.toLowerCase().startsWith(MAPPED_PREFIX)
+        ? remoteAddress.slice(MAPPED_PREFIX.length)
+        : remoteAddress;
+    return IPV4_LOOPBACK.test(plain);
+}
+//# sourceMappingURL=net.js.map

package/dist/util/real-path.d.ts

@@ -1,3 +1,4 @@
-/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does not exist yet. */
+/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does
+ * not exist yet. */
 export declare function realpathOrResolve(p: string): string;
 //# sourceMappingURL=real-path.d.ts.map

package/dist/util/real-path.js

@@ -1,14 +1,15 @@
 // Leaf module: path canonicalisation shared by project identity and the importers.
 import * as fs from 'fs';
 import * as path from 'path';
-import { errorMessage, log } from './log.js';
-/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does not exist yet. */
+import { errorMessage, log, errorFields } from './log.js';
+/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does
+ * not exist yet. */
 export function realpathOrResolve(p) {
     try {
         return fs.realpathSync.native(p);
     }
     catch (err) {
-        log.debug(`realpath fell back to resolve for ${p}: ${errorMessage(err)}`);
+        log.debug(`realpath fell back to resolve for ${p}: ${errorMessage(err)}`, errorFields(err));
         return path.resolve(p);
     }
 }

package/dist/util/request-scope.d.ts

@@ -5,10 +5,15 @@ export interface RequestScope {
     readonly requestId: string | undefined;
     /** Set for a served request that must be answered by a given time. */
     readonly deadline?: RequestDeadline | undefined;
+    /** Aborts when the request passes its deadline, so a handler that checks it stops starting work nobody waits for. */
+    readonly signal?: AbortSignal | undefined;
 }
 /** How long a request may run: 120 s, or HIPPO_REQUEST_DEADLINE_MS, where 0 turns the deadline off. */
 export declare function requestDeadlineMs(): number;
-/** When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`, with the outcome only it knows. */
+/**
+ * When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`,
+ * with the outcome only it knows.
+ */
 export declare class RequestDeadline {
     #private;
     /** Epoch milliseconds. */
@@ -16,7 +21,10 @@ export declare class RequestDeadline {
     constructor(at: number);
     /** Counts `call` as one the request waits on until it settles. */
     track<T>(call: Promise<T>): Promise<T>;
-    /** Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile runs, in order. */
+    /**
+     * Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile
+     * runs, in order.
+     */
     onceIdle(fn: () => void): void;
 }
 export declare const requestScopes: AsyncLocalStorage<RequestScope>;
@@ -24,7 +32,11 @@ export declare const requestScopes: AsyncLocalStorage<RequestScope>;
 export declare function currentRequestId(): string | undefined;
 /** The deadline of the request this code runs for, if it has one. */
 export declare function currentDeadline(): RequestDeadline | undefined;
+/** The abort signal of the request this code runs for, if it has one. */
+export declare function currentSignal(): AbortSignal | undefined;
 /** Runs `fn` with `requestId` on every log line it writes, including the ones from
- * timers and promises it starts. `deadline` reaches every store call made inside. */
-export declare function runWithRequestId<T>(requestId: string, fn: () => T, deadline?: RequestDeadline): T;
+ * timers and promises it starts. `deadline` reaches every store call made inside, and `signal` every check of
+ * `currentSignal`.
+ */
+export declare function runWithRequestId<T>(requestId: string, fn: () => T, deadline?: RequestDeadline, signal?: AbortSignal): T;
 //# sourceMappingURL=request-scope.d.ts.map

package/dist/util/request-scope.js

@@ -1,4 +1,5 @@
-// The one ambient scope of a request. A leaf module, so the logger can read the request id without importing the store layer.
+// The one ambient scope of a request. A leaf module, so the logger can read the request id without importing the store
+// layer.
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { envRequestDeadlineMs } from './env.js';
 const DEFAULT_REQUEST_DEADLINE_MS = 120_000;
@@ -6,7 +7,10 @@ const DEFAULT_REQUEST_DEADLINE_MS = 120_000;
 export function requestDeadlineMs() {
     return envRequestDeadlineMs() ?? DEFAULT_REQUEST_DEADLINE_MS;
 }
-/** When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`, with the outcome only it knows. */
+/**
+ * When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`,
+ * with the outcome only it knows.
+ */
 export class RequestDeadline {
     /** Epoch milliseconds. */
     at;
@@ -28,7 +32,10 @@ export class RequestDeadline {
         call.then(done, done);
         return call;
     }
-    /** Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile runs, in order. */
+    /**
+     * Runs `fn` now, or once the last store call the request waits on has settled; every function registered meanwhile
+     * runs, in order.
+     */
     onceIdle(fn) {
         if (this.#storeCalls === 0)
             fn();
@@ -45,9 +52,15 @@ export function currentRequestId() {
 export function currentDeadline() {
     return requestScopes.getStore()?.deadline;
 }
+/** The abort signal of the request this code runs for, if it has one. */
+export function currentSignal() {
+    return requestScopes.getStore()?.signal;
+}
 /** Runs `fn` with `requestId` on every log line it writes, including the ones from
- * timers and promises it starts. `deadline` reaches every store call made inside. */
-export function runWithRequestId(requestId, fn, deadline) {
-    return requestScopes.run({ requestId, deadline }, fn);
+ * timers and promises it starts. `deadline` reaches every store call made inside, and `signal` every check of
+ * `currentSignal`.
+ */
+export function runWithRequestId(requestId, fn, deadline, signal) {
+    return requestScopes.run({ requestId, deadline, signal }, fn);
 }
 //# sourceMappingURL=request-scope.js.map

package/dist/util/same-text.d.ts

@@ -6,14 +6,21 @@ type Text = Pick<MemoryEntry, 'content'> & {
 export declare function duplicateKey(text: string): string;
 /** A sleep-merged row's text: a header, a blank line, then each text as a "- " bullet with its later lines indented. */
 export declare function mergedText(header: string, texts: readonly string[]): string;
-/** Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header. */
+/**
+ * Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header.
+ */
 export declare function heldTexts(entry: Text): string[];
 /** Keys of every text a row holds word for word: its own, plus each source text inside a sleep-merged row. */
 export declare function heldTextKeys(entry: Text): string[];
-/** The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it. */
+/**
+ * The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it.
+ */
 export declare function longestWord(text: string): string;
 export declare function storedTextKeys(entries: readonly Text[]): Set<string>;
-/** A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and each later unpinned copy of a text. */
+/**
+ * A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and
+ * each later unpinned copy of a text.
+ */
 export declare function dropHeldCopies<T>(rows: readonly T[], textOf: (row: T) => Text): T[];
 export {};
 //# sourceMappingURL=same-text.d.ts.map

package/dist/util/same-text.js

@@ -5,7 +5,9 @@ export function duplicateKey(text) {
 export function mergedText(header, texts) {
     return `${header}\n\n${texts.map((t) => `- ${t.trim().replace(/\n/g, '\n  ')}`).join('\n')}`;
 }
-/** Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header. */
+/**
+ * Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header.
+ */
 export function heldTexts(entry) {
     const cut = entry.content.indexOf('\n\n');
     if (entry.source !== 'consolidation' || cut < 0)
@@ -19,14 +21,19 @@ export function heldTexts(entry) {
 export function heldTextKeys(entry) {
     return [duplicateKey(entry.content), ...heldTexts(entry).map(duplicateKey)];
 }
-/** The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it. */
+/**
+ * The longest word of a text: every row holding the text word for word contains it, so a store lookup can filter on it.
+ */
 export function longestWord(text) {
     return duplicateKey(text).split(' ').reduce((best, w) => (w.length > best.length ? w : best), '');
 }
 export function storedTextKeys(entries) {
     return new Set(entries.flatMap(heldTextKeys));
 }
-/** A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and each later unpinned copy of a text. */
+/**
+ * A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and
+ * each later unpinned copy of a text.
+ */
 export function dropHeldCopies(rows, textOf) {
     const held = new Set(rows.flatMap((r) => heldTextKeys(textOf(r)).slice(1)));
     const seen = new Set();

package/dist/util/secret-detect.d.ts

@@ -1,5 +1,9 @@
-/** Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag). Flagged rows are never shared to
- * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no imports from store/api/shared. */
+/**
+ * Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag).
+ * Flagged rows are never shared to
+ * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no
+ * imports from store/api/shared.
+ */
 /** Result of scanning one memory. `reason` names the tag or pattern that fired. */
 export interface SecretDetection {
     flagged: boolean;
@@ -12,22 +16,35 @@ export declare function detectSecret(entry: {
     content: string;
     tags: string[];
 }): SecretDetection;
-/** Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and co-occurrence guard as `detectSecret`;
+/**
+ * Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and
+ * co-occurrence guard as `detectSecret`;
  * for callers persisting text that skips the capture content gate (e.g. pre-compact snapshot fields). */
 export declare function redactSecrets(text: string): string;
-/** Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids. */
+/**
+ * Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids.
+ */
 export declare function maskEmails(text: string): string;
-/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
+/**
+ * Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and
+ * JWTs.
+ */
 export declare function redactSecretsStrict(text: string): string;
 /** The text a write keeps, plus what to tell its caller about secret material in it. */
 export interface SecretVet {
     content: string;
     warnings: string[];
 }
-/** Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so it is kept and flagged. */
+/**
+ * Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so
+ * it is kept and flagged.
+ */
 export declare function vetSecrets(content: string, tags: readonly string[], scrub: boolean): SecretVet;
 /** Appended to a dead-letter row's error when `redactPayload` changed its body. */
 export declare const DLQ_REDACTED_NOTE = "secret-shaped text redacted, signature dropped; replay needs --force";
-/** `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays byte-identical so its signature still verifies. */
+/**
+ * `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays
+ * byte-identical so its signature still verifies.
+ */
 export declare function redactPayload(raw: string): string;
 //# sourceMappingURL=secret-detect.d.ts.map

package/dist/util/secret-detect.js

@@ -1,5 +1,9 @@
-/** Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag). Flagged rows are never shared to
- * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no imports from store/api/shared. */
+/**
+ * Secret detection for memory content: conservative provider-bounded patterns (a bare `sk-` in prose must not flag).
+ * Flagged rows are never shared to
+ * the global store or injected as ambient context outside their project; explicit recall is unaffected. Leaf module: no
+ * imports from store/api/shared.
+ */
 /** Tags that flag a memory as secret, lower case; detectSecret folds a tag's case before the lookup. */
 export const SECRET_TAGS = new Set([
     'secret', 'api-key', 'apikey', 'credential', 'credentials',
@@ -14,7 +18,8 @@ const SECRET_PATTERNS = [
     { name: 'slack-token', re: /\bxox[baprs]-[A-Za-z0-9-]{10,}/ },
     { name: 'stripe-key', re: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b/ },
     { name: 'google-api-key', re: /\bAIza[0-9A-Za-z_-]{35}(?:\b|(?<=-))/ },
-    // hk_ is hippo's own API key (src/store/auth.ts); npm, Hugging Face, GitLab and Slack webhook shapes follow gitleaks' rules.
+    // hk_ is hippo's own API key (src/store/auth.ts); npm, Hugging Face, GitLab and Slack webhook shapes follow gitleaks'
+    // rules.
     { name: 'hippo-api-key', re: /\bhk_[a-z2-7]{24}\.[a-z2-7]{32}\b/ },
     { name: 'npm-token', re: /\bnpm_[A-Za-z0-9]{36}\b/ },
     { name: 'huggingface-token', re: /\bhf_[A-Za-z]{34}\b/ },
@@ -22,12 +27,14 @@ const SECRET_PATTERNS = [
     { name: 'google-oauth-token', re: /\bya29\.[\w-]{20,}/ },
     { name: 'slack-webhook', re: /\bhooks\.slack\.com\/(?:services|workflows|triggers)\/[A-Za-z0-9+/]{43,56}/ },
     { name: 'private-key-block', re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-    // sk-... (OpenAI/Anthropic) and sk_<vendor>_... shapes; both need a key-ish noun in the content (co-occurrence guard), so prose
+    // sk-... (OpenAI/Anthropic) and sk_<vendor>_... shapes need a key-ish noun nearby (co-occurrence guard), so prose
     // like "the sk- prefix identifies API keys" does not flag but "prod API key sk_live_..." does.
     { name: 'sk-style-key', re: /\bsk-[A-Za-z0-9_-]{20,}/ },
     { name: 'sk-underscore-key', re: /\bsk_[A-Za-z0-9]+_[A-Za-z0-9_]{6,}\b/ },
-    // Value needs 12+ token-safe chars and a digit, or `token = estimateTokens(...)` and user:password@ templates would hide code lessons from ambient context.
-    // Secret names end in the keyword (dbPassword), so the match opens there, no prefix scan; pwd and pass need a _ (OLDPWD, bypass are not secrets).
+    // Value needs 12+ token-safe chars and a digit, or `token = estimateTokens(...)` and user:password@ templates would
+    // hide code lessons from ambient context.
+    // Secret names end in the keyword (dbPassword), so the match opens there, no prefix scan; pwd and pass need a _
+    // (OLDPWD, bypass are not secrets).
     {
         name: 'secret-assignment',
         re: new RegExp(String.raw `(?:(?:api[_-]?key|access[_-]?key|private[_-]?key|secret|token|passw(?:or)?d|(?<=_)(?:pwd|pass))` +
@@ -61,7 +68,9 @@ export function detectSecret(entry) {
     }
     return { flagged: false, reason: null };
 }
-/** Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and co-occurrence guard as `detectSecret`;
+/**
+ * Replace secret-shaped substrings in free text with a redaction marker, using the same `SECRET_PATTERNS` and
+ * co-occurrence guard as `detectSecret`;
  * for callers persisting text that skips the capture content gate (e.g. pre-compact snapshot fields). */
 export function redactSecrets(text) {
     return redactText(text, false);
@@ -69,15 +78,23 @@ export function redactSecrets(text) {
 /** Only a run's first character starts a match, so a long run is scanned once; a
  * domain's first label opens on a letter, so logo@2x.png and react@18.2.0 stay. */
 const EMAIL = /(?<![A-Za-z0-9._%+-])[A-Za-z0-9._%+-]{1,64}@[A-Za-z][A-Za-z0-9-]*(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}\b/g;
-/** Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids. */
+/**
+ * Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids.
+ */
 export function maskEmails(text) {
     return text.replace(EMAIL, '[email]');
 }
-/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
+/**
+ * Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and
+ * JWTs.
+ */
 export function redactSecretsStrict(text) {
     return redactText(text, true);
 }
-/** Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so it is kept and flagged. */
+/**
+ * Write-time veto: `scrub` text no person typed gets capture's strict redaction; typed text is a person's own call, so
+ * it is kept and flagged.
+ */
 export function vetSecrets(content, tags, scrub) {
     const kept = scrub ? redactSecretsStrict(content) : content;
     const warnings = [];
@@ -94,7 +111,10 @@ export function vetSecrets(content, tags, scrub) {
 const JSON_STRING = /"(?:[^"\\]|\\.)*"/g;
 /** Appended to a dead-letter row's error when `redactPayload` changed its body. */
 export const DLQ_REDACTED_NOTE = 'secret-shaped text redacted, signature dropped; replay needs --force';
-/** `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays byte-identical so its signature still verifies. */
+/**
+ * `vetSecrets` redaction for a raw webhook body: JSON stays valid for replay, and an untouched body stays
+ * byte-identical so its signature still verifies.
+ */
 export function redactPayload(raw) {
     try {
         JSON.parse(raw);
@@ -109,12 +129,27 @@ export function redactPayload(raw) {
         return kept === text ? literal : JSON.stringify(kept);
     });
 }
+const PEM_BEGIN = /-----BEGIN [A-Z ]*PRIVATE KEY-----/g;
+const PEM_END = /-----END [A-Z ]*PRIVATE KEY-----/g;
+/** Each PEM/OpenSSH block through its END line, or to the end of a truncated block; one forward scan, so no ReDoS. */
+function redactPemBlocks(text) {
+    let out = '';
+    let from = 0;
+    PEM_BEGIN.lastIndex = 0;
+    for (let begin = PEM_BEGIN.exec(text); begin; begin = PEM_BEGIN.exec(text)) {
+        PEM_END.lastIndex = PEM_BEGIN.lastIndex;
+        const end = PEM_END.exec(text);
+        out += `${text.slice(from, begin.index)}[REDACTED]`;
+        from = end ? PEM_END.lastIndex : text.length;
+        PEM_BEGIN.lastIndex = from;
+    }
+    return out + text.slice(from);
+}
 function redactText(text, strict) {
     if (!text)
         return text;
-    let result = text;
-    // PEM/OpenSSH blocks first: SECRET_PATTERNS only matches BEGIN; consume through END, or to the end of a truncated block.
-    result = result.replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----(?:[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----|[\s\S]*$)/g, '[REDACTED]');
+    // PEM blocks first: SECRET_PATTERNS only matches the BEGIN line.
+    let result = redactPemBlocks(text);
     for (const { name, re } of SECRET_PATTERNS) {
         if (!strict && CO_OCCURRENCE_GUARDED.has(name) && !KEYISH_CONTEXT_RE.test(text))
             continue;