hippo-memory 1.72.0 → 2.0.0

package/dist/store/token-ledger-rows.js

@@ -1,3 +1,4 @@
+import { placeholders } from '../util/sql.js';
 export function insertTokenRow(db, row) {
     db.prepare(`INSERT INTO token_ledger (ts, tenant_id, session_id, surface, event, items, tokens, block_hash)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(row.ts, row.tenantId, row.sessionId, row.surface, row.event, row.items, row.tokens, row.blockHash);
@@ -34,7 +35,7 @@ export function surfaceTotals(db, tenantId, sinceIso) {
 export function sessionTotals(db, tenantId, sinceIso, rereadSurfaces) {
     // SAFETY: the SELECT names exactly these four aggregate columns.
     return db.prepare(`SELECT COUNT(DISTINCT session_id) AS sessions,
-            COUNT(DISTINCT CASE WHEN event <> 'reset' AND surface IN (${rereadSurfaces.map(() => '?').join(', ')}) THEN session_id END) AS hook_sessions,
+            COUNT(DISTINCT CASE WHEN event <> 'reset' AND surface IN (${placeholders(rereadSurfaces.length)}) THEN session_id END) AS hook_sessions,
             COUNT(DISTINCT CASE WHEN event = 'reread' THEN session_id END) AS reread_sessions,
             SUM(CASE WHEN event = 'inject' THEN tokens ELSE 0 END) AS tokens
      FROM token_ledger
@@ -53,7 +54,7 @@ export function sessionTokenRows(db, tenantId, sinceIso) {
 export function injectedBlocks(db, tenantId, sessionId, surfaces) {
     // SAFETY: the SELECT names exactly these three columns.
     return db.prepare(`SELECT ts, surface, tokens FROM token_ledger
-     WHERE tenant_id = ? AND session_id = ? AND event = 'inject' AND surface IN (${surfaces.map(() => '?').join(', ')})`).all(tenantId, sessionId, ...surfaces);
+     WHERE tenant_id = ? AND session_id = ? AND event = 'inject' AND surface IN (${placeholders(surfaces.length)})`).all(tenantId, sessionId, ...surfaces);
 }
 export function deleteRereadRows(db, tenantId, sessionId) {
     db.prepare(`DELETE FROM token_ledger WHERE tenant_id = ? AND session_id = ? AND event = 'reread'`).run(tenantId, sessionId);

package/dist/store/vector-index.js

@@ -2,11 +2,14 @@
 import { getMeta, setMeta, withWriteScope } from '../db/index.js';
 import { onHandle } from './open.js';
 import { DEFAULT_EMBEDDING_MODEL } from '../embeddings/local.js';
-import { float32ToBuffer, initializeParticle, loadPhysicsState, resetAllPhysicsState, savePhysicsState } from '../db/physics-state.js';
+import { loadPhysicsState, resetAllPhysicsState, savePhysicsState } from '../db/physics-state.js';
+import { initializeParticle } from '../core/physics.js';
+import { float32ToBuffer } from '../util/vector-codec.js';
 import { EMBEDDING_MODEL_META_KEY, deleteOrphanVectors, hasStoredVectors, loadVectors, loadVectorViews, replaceAllVectors, storedVectorDims, storedVectorIds, upsertVectors, } from '../db/vector-store.js';
 import { selectEntriesByIds } from './entry-reads.js';
 import { chunked } from '../util/chunked.js';
 import { MEMORY_SELECT_COLUMNS, rowToEntry } from './rows.js';
+import { placeholders } from '../util/sql.js';
 const MAX_BACKFILL_PAGE = 500;
 /** The model the index was built by: the stored identity, else the default model when vectors exist. */
 export function indexedModel(state) {
@@ -98,7 +101,7 @@ function ownedIds(db, ids, tenantId) {
     const owned = new Set();
     for (const chunk of chunked([...new Set(ids)])) {
         // SAFETY: the SELECT names one column, id.
-        const rows = db.prepare(`SELECT id FROM memories WHERE +tenant_id = ? AND id IN (${chunk.map(() => '?').join(', ')})`).all(tenantId, ...chunk);
+        const rows = db.prepare(`SELECT id FROM memories WHERE +tenant_id = ? AND id IN (${placeholders(chunk.length)})`).all(tenantId, ...chunk);
         for (const row of rows)
             owned.add(row.id);
     }

package/dist/util/anthropic-messages.d.ts

@@ -17,6 +17,8 @@ export type AnthropicMessageFailure = {
 } | {
     kind: 'unreadable';
     message: string;
+} | {
+    kind: 'empty';
 };
 export type AnthropicMessageResult = {
     ok: true;
@@ -27,7 +29,7 @@ export type AnthropicMessageResult = {
 };
 /** True for a failure the next call would repeat, so a caller looping over items should stop rather than retry. */
 export declare function isPermanentFailure(failure: AnthropicMessageFailure): boolean;
-/** The reply's first text block, trimmed (empty when the reply has none); never throws. */
+/** The reply's first text block, trimmed; a reply with no text is a failure of kind 'empty'. Never throws. */
 export declare function sendAnthropicMessage(req: AnthropicMessageRequest): Promise<AnthropicMessageResult>;
 /** The text extraction and DAG summaries hand to their `onError` callback. */
 export declare function describeMessageFailure(failure: AnthropicMessageFailure): string;

package/dist/util/anthropic-messages.js

@@ -31,7 +31,7 @@ async function errorSnippet(res) {
     // Masked before the cut, so a key that straddles the cut is never left half shown.
     return redactSecretsStrict(body.replace(/\s+/g, ' ').trim()).slice(0, ERROR_SNIPPET_CHARS);
 }
-/** The reply's first text block, trimmed (empty when the reply has none); never throws. */
+/** The reply's first text block, trimmed; a reply with no text is a failure of kind 'empty'. Never throws. */
 export async function sendAnthropicMessage(req) {
     let res;
     try {
@@ -58,7 +58,8 @@ export async function sendAnthropicMessage(req) {
         const data = await readCappedJson(res, MAX_REPLY_BYTES);
         if (!isJsonObject(data))
             return { ok: false, failure: { kind: 'unreadable', message: 'the reply is not a JSON object' } };
-        return { ok: true, text: firstText(data) };
+        const text = firstText(data);
+        return text === '' ? { ok: false, failure: { kind: 'empty' } } : { ok: true, text };
     }
     catch (err) {
         return { ok: false, failure: { kind: 'unreadable', message: errorMessage(err) } };
@@ -70,6 +71,7 @@ export function describeMessageFailure(failure) {
         case 'request': return `request failed: ${failure.message}`;
         case 'http': return failure.detail ? `HTTP ${failure.status}: ${failure.detail}` : `HTTP ${failure.status}`;
         case 'unreadable': return `unparseable response: ${failure.message}`;
+        case 'empty': return 'the reply held no text';
     }
 }
 //# sourceMappingURL=anthropic-messages.js.map

package/dist/util/atomic-write.d.ts

@@ -1,4 +1,7 @@
 /** Replaces `file` through a flushed temp file and a rename, so a reader, or a crash at any point, finds the old content or the new, whole.
- *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated. */
-export declare function writeFileAtomic(file: string, text: string): void;
+ *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated.
+ *  `durable: false` skips the fsyncs for derived files that can be rebuilt; a reader still never sees a torn file. */
+export declare function writeFileAtomic(file: string, text: string, opts?: {
+    readonly durable?: boolean;
+}): void;
 //# sourceMappingURL=atomic-write.d.ts.map

package/dist/util/atomic-write.js

@@ -53,13 +53,14 @@ function removeTemp(tmp) {
     }
 }
 /** Flushed before the rename, or a crash soon after could leave the file's name on bytes that never reached the disk. */
-function writeFlushed(tmp, text, old) {
+function writeFlushed(tmp, text, old, durable) {
     const fd = fs.openSync(tmp, 'w', (old?.mode ?? 0o666) & 0o777);
     try {
         fs.writeFileSync(fd, text, 'utf8');
         if (old)
             keepAccess(tmp, old);
-        fs.fsyncSync(fd);
+        if (durable)
+            fs.fsyncSync(fd);
     }
     finally {
         fs.closeSync(fd);
@@ -82,17 +83,18 @@ function flushFolder(dir) {
         log.warn(`could not flush the folder ${dir} to disk after replacing a file in it: ${errorMessage(err)}`);
     }
 }
-function replaceViaTemp(target, text, old) {
+function replaceViaTemp(target, text, old, durable) {
     const tmp = `${target}.${process.pid}.tmp`;
     try {
-        writeFlushed(tmp, text, old);
+        writeFlushed(tmp, text, old, durable);
         renameOnto(tmp, target);
     }
     catch (err) {
         removeTemp(tmp);
         throw err;
     }
-    flushFolder(path.dirname(target));
+    if (durable)
+        flushFolder(path.dirname(target));
 }
 /** The pre-rename write: it truncates first, so it is only the fallback, but it needs just a writable file and keeps hard links together. */
 function writeInPlace(target, text) {
@@ -109,8 +111,10 @@ function writeInPlace(target, text) {
     }
 }
 /** Replaces `file` through a flushed temp file and a rename, so a reader, or a crash at any point, finds the old content or the new, whole.
- *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated. */
-export function writeFileAtomic(file, text) {
+ *  A file with other hard links, or a rename the platform refuses (logged), is written in place: a crash mid-write can leave it truncated.
+ *  `durable: false` skips the fsyncs for derived files that can be rebuilt; a reader still never sees a torn file. */
+export function writeFileAtomic(file, text, opts = {}) {
+    const durable = opts.durable !== false;
     const target = writeTarget(file);
     const old = fs.statSync(target, { throwIfNoEntry: false });
     if (old === undefined) {
@@ -126,7 +130,7 @@ export function writeFileAtomic(file, text) {
         return;
     }
     try {
-        replaceViaTemp(target, text, old);
+        replaceViaTemp(target, text, old, durable);
     }
     catch (err) {
         if (!(err instanceof Error) || !REPLACE_REFUSALS.includes(errnoCode(err)))

package/dist/util/env.d.ts

@@ -22,6 +22,8 @@ export declare function envHippoHome(): string | undefined;
 export declare function envXdgDataHome(): string | undefined;
 export declare function envHomeDir(): string | undefined;
 export declare function envPath(): string | undefined;
+/** The extensions win32 tries on a bare command name, in order. */
+export declare function envPathExt(): string | undefined;
 export declare function envModelCache(): string | undefined;
 export declare function envHippoSessionId(): string | undefined;
 export declare function envClaudeCodeSessionId(): string | undefined;
@@ -47,9 +49,15 @@ export declare function envPort(): string | undefined;
 /** How long a client waits for a running server's /health before writing to the store directly; server-detect.ts holds the default. */
 export declare function envHealthProbeMs(): number | undefined;
 export declare function envRequireAuth(): boolean;
-/** `1` lets a request made on this machine in with no key, as host admin; HIPPO_REQUIRE_AUTH=1 wins over it. */
+/** `1` lets a request made on this machine in with no key; HIPPO_REQUIRE_AUTH=1 wins over it. */
 export declare function envAllowKeylessLocal(): boolean;
+/** The role a keyless local request gets: `admin` (host admin) only when asked for by name, else `member`. */
+export declare function envKeylessLocalRole(): 'admin' | 'member';
+/** `1` lets a non-loopback bind start without TLS, for TLS that ends at a proxy in front. */
+export declare function envAllowCleartext(): boolean;
 export declare function envV1Rps(): string | undefined;
+/** Requests per second each authenticated caller may make; `0` turns the per-caller limit off. */
+export declare function envCallerRps(): string | undefined;
 /** How long a request body may take to arrive; http-util.ts holds the default. */
 export declare function envBodyTimeoutMs(): number | undefined;
 /** How long POST /v1/sleep lets its consolidation run; server/sleep-offload.ts holds the default. */
@@ -63,6 +71,7 @@ export declare function envStoreQueueMax(): number | undefined;
 export declare function envDailyStepTimeoutMs(): number | undefined;
 export declare function envApiKey(): string | undefined;
 export declare function envClientIpHeader(): string | undefined;
+/** The peers whose HIPPO_CLIENT_IP_HEADER is believed: IPs or CIDRs, or `*` for any peer. */
 export declare function envTrustedProxies(): string | undefined;
 /** Paths to the PEM certificate and key `hippo serve` answers HTTPS with; the --tls-cert and --tls-key flags win. */
 export declare function envTlsCert(): string | undefined;

package/dist/util/env.js

@@ -64,6 +64,8 @@ export function envHippoHome() { return raw('HIPPO_HOME')?.trim(); }
 export function envXdgDataHome() { return raw('XDG_DATA_HOME')?.trim(); }
 export function envHomeDir() { return raw('HOME') || raw('USERPROFILE'); }
 export function envPath() { return raw('PATH'); }
+/** The extensions win32 tries on a bare command name, in order. */
+export function envPathExt() { return raw('PATHEXT'); }
 export function envModelCache() { return trimmed('HIPPO_MODEL_CACHE'); }
 // Session, scope and tenant.
 export function envHippoSessionId() { return trimmed('HIPPO_SESSION_ID'); }
@@ -94,9 +96,15 @@ export function envPort() { return raw('HIPPO_PORT'); }
 /** How long a client waits for a running server's /health before writing to the store directly; server-detect.ts holds the default. */
 export function envHealthProbeMs() { return positiveInt('HIPPO_HEALTH_PROBE_MS'); }
 export function envRequireAuth() { return isOne('HIPPO_REQUIRE_AUTH'); }
-/** `1` lets a request made on this machine in with no key, as host admin; HIPPO_REQUIRE_AUTH=1 wins over it. */
+/** `1` lets a request made on this machine in with no key; HIPPO_REQUIRE_AUTH=1 wins over it. */
 export function envAllowKeylessLocal() { return isOne('HIPPO_ALLOW_KEYLESS_LOCAL'); }
+/** The role a keyless local request gets: `admin` (host admin) only when asked for by name, else `member`. */
+export function envKeylessLocalRole() { return trimmed('HIPPO_KEYLESS_LOCAL_ROLE')?.toLowerCase() === 'admin' ? 'admin' : 'member'; }
+/** `1` lets a non-loopback bind start without TLS, for TLS that ends at a proxy in front. */
+export function envAllowCleartext() { return isOne('HIPPO_ALLOW_CLEARTEXT'); }
 export function envV1Rps() { return raw('HIPPO_V1_RPS'); }
+/** Requests per second each authenticated caller may make; `0` turns the per-caller limit off. */
+export function envCallerRps() { return trimmed('HIPPO_CALLER_RPS'); }
 /** How long a request body may take to arrive; http-util.ts holds the default. */
 export function envBodyTimeoutMs() { return positiveInt('HIPPO_BODY_TIMEOUT_MS'); }
 /** How long POST /v1/sleep lets its consolidation run; server/sleep-offload.ts holds the default. */
@@ -110,6 +118,7 @@ export function envStoreQueueMax() { return positiveInt('HIPPO_STORE_QUEUE_MAX')
 export function envDailyStepTimeoutMs() { return positiveInt('HIPPO_DAILY_STEP_TIMEOUT_MS'); }
 export function envApiKey() { return raw('HIPPO_API_KEY'); }
 export function envClientIpHeader() { return raw('HIPPO_CLIENT_IP_HEADER')?.trim().toLowerCase(); }
+/** The peers whose HIPPO_CLIENT_IP_HEADER is believed: IPs or CIDRs, or `*` for any peer. */
 export function envTrustedProxies() { return raw('HIPPO_TRUSTED_PROXIES'); }
 /** Paths to the PEM certificate and key `hippo serve` answers HTTPS with; the --tls-cert and --tls-key flags win. */
 export function envTlsCert() { return trimmed('HIPPO_TLS_CERT'); }

package/dist/util/format.d.ts

@@ -1,3 +1,5 @@
 /** A 0..1 fraction as a percentage with one decimal, e.g. 0.256 -> "25.6%". */
 export declare function pct(fraction: number): string;
+/** Rounds to one decimal place. */
+export declare function round1(value: number): number;
 //# sourceMappingURL=format.d.ts.map

package/dist/util/format.js

@@ -3,4 +3,8 @@
 export function pct(fraction) {
     return (fraction * 100).toFixed(1) + '%';
 }
+/** Rounds to one decimal place. */
+export function round1(value) {
+    return Math.round(value * 10) / 10;
+}
 //# sourceMappingURL=format.js.map

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

@@ -5,6 +5,8 @@ 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;
@@ -24,7 +26,9 @@ 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

@@ -45,9 +45,13 @@ 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/spawn-argv.d.ts

@@ -0,0 +1,9 @@
+import { type ChildProcess, type SpawnOptions } from 'node:child_process';
+/** Quotes one cmd.exe argument; each `%` leaves the quotes as `^%`, so no %NAME% pair can expand. */
+export declare function quoteCmdArg(arg: string): string;
+/** cmd.exe arguments that run a .cmd or .bat shim with every forwarded argument delivered verbatim. */
+export declare function cmdShimArgs(shimPath: string, forwardArgs: readonly string[]): string[];
+/** Spawns argv[0] with the rest as its arguments and no shell. Node refuses to start a .cmd or .bat without one (CVE-2024-27980),
+ *  so on win32 such a shim runs through cmd.exe with every argument quoted for it. */
+export declare function spawnArgv(argv: readonly string[], options: SpawnOptions): ChildProcess;
+//# sourceMappingURL=spawn-argv.d.ts.map

package/dist/util/spawn-argv.js

@@ -0,0 +1,57 @@
+// Starting a command from an argv list with no shell, Windows .cmd and .bat shims included, so no argument is ever parsed as shell syntax.
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { envPath, envPathExt } from './env.js';
+/** Quotes one cmd.exe argument; each `%` leaves the quotes as `^%`, so no %NAME% pair can expand. */
+export function quoteCmdArg(arg) {
+    if (arg.length === 0)
+        return '""';
+    if (!/[ \t"&()^<>|%!]/.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '""').replace(/%/g, '"^%"')}"`;
+}
+/** cmd.exe arguments that run a .cmd or .bat shim with every forwarded argument delivered verbatim. */
+export function cmdShimArgs(shimPath, forwardArgs) {
+    const command = `"${shimPath}"${forwardArgs.length > 0 ? ` ${forwardArgs.map(quoteCmdArg).join(' ')}` : ''}`;
+    // The line is already quoted for cmd.exe, so Node must not quote it again; /s strips the outer pair.
+    return ['/d', '/v:off', '/s', '/c', `"${command}"`];
+}
+const DEFAULT_PATHEXT = '.COM;.EXE;.BAT;.CMD';
+function isFile(candidate) {
+    return fs.statSync(candidate, { throwIfNoEntry: false })?.isFile() === true;
+}
+/** The file `command` names on win32: as given when it has a folder, else the first hit in the working folder then PATH, trying each PATHEXT. */
+function resolveWindowsCommand(command) {
+    const exts = (envPathExt() ?? DEFAULT_PATHEXT).split(';').filter((ext) => ext.length > 0);
+    const dirs = /[\\/]/.test(command) ? [''] : [process.cwd(), ...(envPath() ?? '').split(path.delimiter).filter((dir) => dir.length > 0)];
+    for (const dir of dirs) {
+        const base = dir === '' ? command : path.join(dir, command);
+        const candidates = path.extname(command) === '' ? exts.map((ext) => base + ext) : [base, ...exts.map((ext) => base + ext)];
+        const hit = candidates.find(isFile);
+        if (hit !== undefined)
+            return hit;
+    }
+    return null;
+}
+/** Spawns argv[0] with the rest as its arguments and no shell. Node refuses to start a .cmd or .bat without one (CVE-2024-27980),
+ *  so on win32 such a shim runs through cmd.exe with every argument quoted for it. */
+export function spawnArgv(argv, options) {
+    const [command, ...args] = argv;
+    if (command === undefined || command.length === 0)
+        throw new RangeError('spawnArgv needs a command: argv is empty');
+    if (process.platform === 'win32') {
+        const resolved = resolveWindowsCommand(command);
+        const ext = resolved === null ? '' : path.extname(resolved).toLowerCase();
+        if (resolved !== null && (ext === '.cmd' || ext === '.bat')) {
+            return spawn('cmd.exe', cmdShimArgs(resolved, args), {
+                ...options,
+                windowsHide: options.windowsHide ?? true,
+                shell: false,
+                windowsVerbatimArguments: true,
+            });
+        }
+    }
+    return spawn(command, args, { ...options, windowsHide: options.windowsHide ?? true, shell: false });
+}
+//# sourceMappingURL=spawn-argv.js.map

package/dist/util/sql.d.ts

@@ -0,0 +1,3 @@
+/** `n` bound-parameter marks joined for an IN list or VALUES row, e.g. 3 -> "?, ?, ?". */
+export declare function placeholders(n: number): string;
+//# sourceMappingURL=sql.d.ts.map

package/dist/util/sql.js

@@ -0,0 +1,6 @@
+// SQL text helpers shared by every layer that builds an IN list or VALUES row.
+/** `n` bound-parameter marks joined for an IN list or VALUES row, e.g. 3 -> "?, ?, ?". */
+export function placeholders(n) {
+    return Array.from({ length: n }, () => '?').join(', ');
+}
+//# sourceMappingURL=sql.js.map

package/dist/util/vector-codec.d.ts

@@ -0,0 +1,4 @@
+/** Float32 vector <-> Buffer codec for BLOB columns. */
+export declare function float32ToBuffer(arr: number[]): Buffer;
+export declare function bufferToFloat32(buf: Buffer | Uint8Array): number[];
+//# sourceMappingURL=vector-codec.d.ts.map

package/dist/util/vector-codec.js

@@ -0,0 +1,15 @@
+/** Float32 vector <-> Buffer codec for BLOB columns. */
+export function float32ToBuffer(arr) {
+    const f32 = new Float32Array(arr);
+    return Buffer.from(f32.buffer);
+}
+export function bufferToFloat32(buf) {
+    if (buf.byteLength === 0 || buf.byteLength % 4 !== 0)
+        return [];
+    // Ensure we have a properly aligned copy (SQLite may return Uint8Array, not Buffer)
+    const bytes = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    const aligned = new ArrayBuffer(bytes.length);
+    new Uint8Array(aligned).set(bytes);
+    return Array.from(new Float32Array(aligned));
+}
+//# sourceMappingURL=vector-codec.js.map

package/dist/util/version.d.ts

@@ -1,6 +1,6 @@
 /** Single source of truth for the package version, written by scripts/sync-version.mjs; never edit by hand. Read by the db rollback guard, /health, MCP.
  * A constant, not a runtime package.json read: the published bundle may lack package.json on a path ESM can resolve. */
-export declare const PACKAGE_VERSION = "1.72.0";
+export declare const PACKAGE_VERSION = "2.0.0";
 /** The floor a store takes on its first expiring key: the first release with schema
  * v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export declare const EXPIRING_KEYS_MIN_BINARY = "1.64.0";

package/dist/util/version.js

@@ -1,6 +1,6 @@
 /** Single source of truth for the package version, written by scripts/sync-version.mjs; never edit by hand. Read by the db rollback guard, /health, MCP.
  * A constant, not a runtime package.json read: the published bundle may lack package.json on a path ESM can resolve. */
-export const PACKAGE_VERSION = '1.72.0';
+export const PACKAGE_VERSION = '2.0.0';
 /** The floor a store takes on its first expiring key: the first release with schema
  * v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export const EXPIRING_KEYS_MIN_BINARY = '1.64.0';

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.72.0",
+  "version": "2.0.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.72.0",
+  "version": "2.0.0",
   "type": "module",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.72.0",
+  "version": "2.0.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.72.0",
+  "version": "2.0.0",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",
@@ -8,6 +8,8 @@
   "exports": {
     ".": "./dist/index.js",
     "./server": "./dist/server.js",
+    "./store-kit": "./dist/entry/store-kit.js",
+    "./testing": "./dist/entry/testing.js",
     "./project-identity": "./dist/entry/project-identity.js",
     "./json-hooks": "./dist/entry/json-hooks.js",
     "./session-text": "./dist/entry/session-text.js"

package/dist/api/on-store.d.ts

@@ -1,16 +0,0 @@
-import type { HippoStore, StoreGroups } from '../store/port.js';
-import { type SqliteLocal } from '../store/sqlite/local.js';
-import { type SqliteSyncStore } from '../store/sqlite/store.js';
-import type { Context, StoreReply } from './types.js';
-/** What a port call answers: a Promise from a served store, the value itself from hippo.db. */
-export type Reply<T> = T | Promise<T>;
-/** The port one body is written against: a served store, or hippo.db answering the same methods at once. */
-export type StorePort = HippoStore | SqliteSyncStore;
-/** `next` on the reply's value, at once for a value, so hippo.db's path never becomes a Promise. */
-export declare function andThen<T, U>(reply: Reply<T>, next: (value: T) => Reply<U>): Reply<U>;
-/** Stands in for a group the store lacks, as `port.keyAudit ?? notPorted(port, 'keyAudit')`; it answers 501 as any unported path does. */
-export declare function notPorted(port: StorePort, group: keyof StoreGroups): never;
-/** Runs `run` on `ctx.store`, where a throw rejects, else on hippo.db under `ctx.hippoRoot`, where it throws. The store path never reads `hippoRoot`.
- *  `local` runs what needs hippo.db's own handle or meta table; a served store refuses it, or does without where the write allows. */
-export declare function onStore<C extends Context, R>(ctx: C, run: (port: StorePort, local: SqliteLocal) => Reply<R>): StoreReply<C, R>;
-//# sourceMappingURL=on-store.d.ts.map

package/dist/api/on-store.js

@@ -1,38 +0,0 @@
-// The one place an api function picks between a served store and hippo.db, so each operation has one body.
-// Only functions published as StoreReply use this carrier (see "Sync core, async port" in docs/ARCHITECTURE.md);
-// a new operation is async and goes through storeFor(ctx).
-import { SqliteBlockedError, StoreNotPortedError } from '../util/sqlite-blocked.js';
-import { REFUSED_ON_A_STORE, sqliteLocal } from '../store/sqlite/local.js';
-import { sqliteSyncStore } from '../store/sqlite/store.js';
-/** `next` on the reply's value, at once for a value, so hippo.db's path never becomes a Promise. */
-export function andThen(reply, next) {
-    return reply instanceof Promise ? reply.then(next) : next(reply);
-}
-/** Stands in for a group the store lacks, as `port.keyAudit ?? notPorted(port, 'keyAudit')`; it answers 501 as any unported path does. */
-export function notPorted(port, group) {
-    throw new StoreNotPortedError(port.kind, group);
-}
-/** A served store's stand-in for SqliteLocal. The last recall sits in hippo.db's
- * meta table, so only a store that is hippo.db keeps and reads it, on `hippoRoot`. */
-function servedLocal(store, hippoRoot) {
-    if (store.kind === 'sqlite')
-        return { ...sqliteLocal(hippoRoot), ...REFUSED_ON_A_STORE };
-    return {
-        ...REFUSED_ON_A_STORE,
-        applyOutcomeToLastRecall() {
-            throw new SqliteBlockedError(store.kind);
-        },
-        finishLastRecall: (writes) => store.finishRecall(writes).then(() => null),
-    };
-}
-/** Runs `run` on `ctx.store`, where a throw rejects, else on hippo.db under `ctx.hippoRoot`, where it throws. The store path never reads `hippoRoot`.
- *  `local` runs what needs hippo.db's own handle or meta table; a served store refuses it, or does without where the write allows. */
-export function onStore(ctx, run) {
-    const { store } = ctx;
-    // No await before `run`: an add-on relies on the first port call starting inside this call.
-    const reply = store ? (async () => run(store, servedLocal(store, ctx.hippoRoot)))() : run(sqliteSyncStore(ctx.hippoRoot), sqliteLocal(ctx.hippoRoot));
-    // SAFETY: the store path is an async function's Promise and hippo.db's port calls answer
-    // values, so the Promise comes back exactly when ctx has a store, as StoreReply says.
-    return reply;
-}
-//# sourceMappingURL=on-store.js.map

package/dist/cli/lenient-id.d.ts

@@ -1,2 +0,0 @@
-export declare function parseObjectId(idRaw: string, noun: string): number;
-//# sourceMappingURL=lenient-id.d.ts.map

package/dist/cli/lenient-id.js

@@ -1,13 +0,0 @@
-// The id parser the predict and decide verbs share.
-import { printError } from './output.js';
-import { CliExit } from './exit.js';
-// Lenient on purpose (parseInt reads "1abc" as 1) until the next major version; the other object verbs use the strict parser.
-export function parseObjectId(idRaw, noun) {
-    const id = parseInt(String(idRaw), 10);
-    if (!Number.isFinite(id) || id <= 0) {
-        printError(`Invalid ${noun} id: "${idRaw}"`);
-        throw new CliExit(1);
-    }
-    return id;
-}
-//# sourceMappingURL=lenient-id.js.map