hippo-memory 1.68.0 → 1.70.0

package/dist/server/routes/memories.js

@@ -1,12 +1,13 @@
 // Memory write routes: create, graph, archive, supersede, promote, forget, outcome, sleep.
-import { archiveRaw, forget, outcome, outcomeForLastRecall, promote, remember, sleep, supersede } from '../../api.js';
-import { buildGraphModel } from '../../graph-view.js';
-import { MAX_ENTITY_NAME_LEN } from '../../graph/types.js';
-import { HttpError, sendJson } from '../../http-util.js';
-import { canReadScope } from '../../recall-scope.js';
+import { archiveRaw, forget, outcome, outcomeForLastRecall, promote, remember, supersede } from '../../api/index.js';
+import { graphModelOf } from '../../graph/view.js';
+import { MAX_ENTITY_NAME_LEN } from '../../store/graph-rows.js';
+import { HttpError, sendJson } from '../../util/http-util.js';
+import { requireGroup } from '../../store/port.js';
 import { assertCrossTenantAdmin, buildContextWithAuth, isLoopback } from '../auth.js';
-import { getCallerProject, getString, getStringArray, isJsonBoolean, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
-import { isJsonString } from '../../json.js';
+import { sleepInChild } from '../sleep-offload.js';
+import { getCallerProject, getString, getStringArray, isSetMember, parseJsonBody, parseListLimit, validateIdSegment } from '../validation.js';
+import { isJsonString, isJsonBoolean } from '../../util/json.js';
 const VALID_KINDS = new Set([
     'raw',
     'distilled',
@@ -29,7 +30,7 @@ export async function handleCreateMemory({ req, res, opts }) {
     if (personalRaw !== undefined && !isJsonBoolean(personalRaw)) {
         throw new HttpError(400, 'personal must be a boolean');
     }
-    const result = remember(ctx, {
+    const result = await remember(ctx, {
         content,
         kind: kindRaw,
         scope: getString(body, 'scope'),
@@ -52,12 +53,9 @@ export async function handleGetGraph({ req, res, opts, query }) {
     }
     const limit = parseListLimit(query.get('limit'));
     const ctx = await buildContextWithAuth(req, opts);
-    const model = buildGraphModel(ctx.hippoRoot, ctx.tenantId, {
-        entity: entityRaw ?? undefined,
-        limit,
-        canRead: (s) => s === null || canReadScope(ctx.actor, s),
-    });
-    sendJson(res, 200, model);
+    const { role, scopes, owner } = ctx.actor;
+    const rows = await requireGroup(opts.store, 'graphReads').graphRows(ctx.tenantId, { entity: entityRaw ?? undefined, limit, reader: { role, scopes, owner } });
+    sendJson(res, 200, graphModelOf(rows));
     return;
 }
 // /v1/memories/:id/* and DELETE /v1/memories/:id
@@ -69,7 +67,7 @@ export async function handleArchiveMemory({ req, res, opts }, archiveMatch) {
     if (!reason) {
         throw new HttpError(400, 'reason is required');
     }
-    const result = archiveRaw(ctx, archiveMatch.id, reason);
+    const result = await archiveRaw(ctx, archiveMatch.id, reason);
     sendJson(res, 200, result);
     return;
 }
@@ -81,7 +79,7 @@ export async function handleSupersedeMemory({ req, res, opts }, supersedeMatch)
     if (!content) {
         throw new HttpError(400, 'content is required');
     }
-    const result = supersede(ctx, supersedeMatch.id, content);
+    const result = await supersede(ctx, supersedeMatch.id, content);
     sendJson(res, 200, result);
     return;
 }
@@ -95,7 +93,7 @@ export async function handlePromoteMemory({ req, res, opts }, promoteMatch) {
 export async function handleForgetMemory({ req, res, opts }, idMatch) {
     validateIdSegment(idMatch.id, 'memory id');
     const ctx = await buildContextWithAuth(req, opts);
-    const result = forget(ctx, idMatch.id);
+    const result = await forget(ctx, idMatch.id);
     sendJson(res, 200, result);
     return;
 }
@@ -132,11 +130,14 @@ export async function handleApplyOutcome({ req, res, opts }) {
         ids = idsRaw;
     }
     if (ids !== undefined) {
-        const { applied } = outcome(ctx, ids, good);
+        const { applied } = await outcome(ctx, ids, good);
         sendJson(res, 200, { applied });
     }
     else {
-        const result = outcomeForLastRecall(ctx, good);
+        // The last recall's ids live in hippo.db alone, so a client of another store must send the ids its recall returned.
+        if (ctx.store !== undefined && ctx.store.kind !== 'sqlite')
+            throw new HttpError(501, 'this store keeps no last recall: send the ids your recall returned');
+        const result = await outcomeForLastRecall(ctx, good);
         sendJson(res, 200, result);
     }
     return;
@@ -177,7 +178,7 @@ export async function handleSleep({ req, res, opts }) {
         throw new HttpError(400, 'no_share must be a boolean');
     }
     // sleepCtx already built above for the admin-role gate; reuse.
-    const result = await sleep(sleepCtx, {
+    const result = await sleepInChild(sleepCtx, {
         dryRun: dryRunRaw === true,
         noShare: noShareRaw === true,
     });

package/dist/server/routes/object-routes.d.ts

@@ -0,0 +1,40 @@
+import { type JsonValue } from '../../util/json.js';
+import type { ObjectDescriptor, SavableDescriptor } from '../../objects/descriptor.js';
+import type { ObjectByKind, ObjectKind, SavableKind } from '../../store/object-types.js';
+import { type Objects } from '../../store/port.js';
+import type { RouteRequest } from '../types.js';
+export interface ObjectRouteConfig<K extends ObjectKind> {
+    /** Names the object in the 404 text, e.g. "customer note". */
+    readonly noun: string;
+    /** Reply field that carries one object, e.g. "note". */
+    readonly field: string;
+    /** Reply field that carries a page, e.g. "notes". */
+    readonly listField: string;
+    /** The bad-status reply lists `object.states` in the set's own order. */
+    readonly object: ObjectDescriptor<K>;
+    /** List query parameter matched against the kind's filter column, e.g. "customer". */
+    readonly filterParam?: string;
+}
+export interface VersionedRouteConfig<K extends SavableKind, W> extends ObjectRouteConfig<K> {
+    readonly object: SavableDescriptor<K, W>;
+    /** Checks the body, then returns the successor's write; split in two so a bad body answers 400 before a missing row answers 404. */
+    readonly revise: (body: Record<string, JsonValue>) => (existing: ObjectByKind[K], id: number) => W;
+}
+export interface RequiredStringRule {
+    readonly max: number;
+    /** The field name is a plural noun, so the replies read "are required" and "exceed". */
+    readonly plural?: boolean;
+    /** The blank check does not trim, so a value of only spaces passes it. */
+    readonly untrimmed?: boolean;
+}
+export declare function requiredString(body: Record<string, JsonValue>, key: string, rule: RequiredStringRule): string;
+export declare function optionalString(body: Record<string, JsonValue>, key: string, max: number): string | undefined;
+/** The request store's object group; the dispatcher has already answered 501 for a store without it. */
+export declare function objectsOf({ opts }: RouteRequest): Objects;
+/** Saves through the request's store as the authenticated caller. */
+export declare function saveFor<K extends SavableKind, W>(rr: RouteRequest, d: SavableDescriptor<K, W>, tenantId: string, actor: string, write: W): Promise<ObjectByKind[K]>;
+export declare function listRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: RouteRequest): Promise<void>;
+export declare function getRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function closeRoute<K extends ObjectKind>(cfg: ObjectRouteConfig<K>, rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function supersedeRoute<K extends SavableKind, W>(cfg: VersionedRouteConfig<K, W>, rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+//# sourceMappingURL=object-routes.d.ts.map

package/dist/server/routes/object-routes.js

@@ -0,0 +1,80 @@
+// List, get, close and supersede handlers shared by the typed-object routes; each route file passes one config.
+import { HttpError, sendJson } from '../../util/http-util.js';
+import { isJsonString } from '../../util/json.js';
+import { closeObject, listObjects, objectById, saveObject } from '../../objects/lifecycle.js';
+import { requireGroup } from '../../store/port.js';
+import { buildContextWithAuth } from '../auth.js';
+import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
+import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+export function requiredString(body, key, rule) {
+    const value = body[key];
+    if (!isJsonString(value) || (rule.untrimmed ? value : value.trim()).length === 0) {
+        throw new HttpError(400, `${key} ${rule.plural ? 'are' : 'is'} required (non-empty string)`);
+    }
+    if (value.length > rule.max) {
+        throw new HttpError(400, `${key} ${rule.plural ? 'exceed' : 'exceeds'} ${rule.max}-character cap`);
+    }
+    return value;
+}
+export function optionalString(body, key, max) {
+    const value = body[key];
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isJsonString(value))
+        throw new HttpError(400, `${key} must be a string`);
+    if (value.length > max)
+        throw new HttpError(400, `${key} exceeds ${max}-character cap`);
+    return value;
+}
+/** The request store's object group; the dispatcher has already answered 501 for a store without it. */
+export function objectsOf({ opts }) {
+    return requireGroup(opts.store, 'objects');
+}
+/** Saves through the request's store as the authenticated caller. */
+export function saveFor(rr, d, tenantId, actor, write) {
+    return saveObject(objectsOf(rr), d, { hippoRoot: rr.opts.hippoRoot, tenantId, actor }, write);
+}
+async function found(cfg, objects, tenantId, id) {
+    const row = await objectById(objects, cfg.object, tenantId, id);
+    if (!row)
+        throw new HttpError(404, `${cfg.noun} ${id} not found`);
+    return row;
+}
+// Limit and cursor are checked before auth and status after it, so a keyless caller gets 400 for the first two and 401 for a bad status.
+export async function listRoute(cfg, rr) {
+    const { req, res, opts, query } = rr;
+    const status = query.get('status') ?? 'all';
+    const filter = cfg.filterParam === undefined ? null : query.get(cfg.filterParam);
+    const limit = parseListLimit(query.get('limit'));
+    const after = parseCursor(query.get('cursor'), 'string', 'integer');
+    const ctx = await buildContextWithAuth(req, opts);
+    const listOpts = { limit: limit + 1, after, filter: filter?.trim() || undefined };
+    if (status !== 'all') {
+        const states = cfg.object.states;
+        if (!isSetMember(states, status)) {
+            throw new HttpError(400, `status must be one of: ${[...states].join(' | ')} | all (got "${status}")`);
+        }
+        listOpts.status = status;
+    }
+    const page = pageOf(await listObjects(objectsOf(rr), cfg.object, ctx.tenantId, listOpts), limit, byCreatedAt);
+    sendJson(res, 200, { [cfg.listField]: page.items, next_cursor: page.nextCursor });
+}
+export async function getRoute(cfg, rr, match) {
+    const id = parseInt(match[1], 10);
+    const ctx = await buildContextWithAuth(rr.req, rr.opts);
+    sendJson(rr.res, 200, { [cfg.field]: await found(cfg, objectsOf(rr), ctx.tenantId, id) });
+}
+export async function closeRoute(cfg, rr, match) {
+    const id = parseInt(match[1], 10);
+    const ctx = await buildContextWithAuth(rr.req, rr.opts);
+    sendJson(rr.res, 200, { [cfg.field]: await closeObject(objectsOf(rr), cfg.object, ctx.tenantId, id, ctx.actor.subject) });
+}
+export async function supersedeRoute(cfg, rr, match) {
+    const id = parseInt(match[1], 10);
+    const ctx = await buildContextWithAuth(rr.req, rr.opts);
+    const successor = cfg.revise(await parseJsonBody(rr.req, ctx));
+    const existing = await found(cfg, objectsOf(rr), ctx.tenantId, id);
+    const saved = await saveFor(rr, cfg.object, ctx.tenantId, ctx.actor.subject, successor(existing, id));
+    sendJson(rr.res, 200, { [cfg.field]: saved });
+}
+//# sourceMappingURL=object-routes.js.map

package/dist/server/routes/policies.d.ts

@@ -1,8 +1,8 @@
 import type { RouteRequest } from '../types.js';
-export declare function handleCreatePolicy({ req, res, opts }: RouteRequest): Promise<void>;
-export declare function handleListPolicies({ req, res, opts, query }: RouteRequest): Promise<void>;
-export declare function handlePoliciesAsOf({ req, res, opts, query }: RouteRequest): Promise<void>;
-export declare function handleSupersedePolicy({ req, res, opts }: RouteRequest, policySupersedeMatch: RegExpMatchArray): Promise<void>;
-export declare function handleClosePolicy({ req, res, opts }: RouteRequest, policyCloseMatch: RegExpMatchArray): Promise<void>;
-export declare function handleGetPolicy({ req, res, opts }: RouteRequest, policyByIdMatch: RegExpMatchArray): Promise<void>;
+export declare function handleCreatePolicy(rr: RouteRequest): Promise<void>;
+export declare function handleListPolicies(rr: RouteRequest): Promise<void>;
+export declare function handlePoliciesAsOf(rr: RouteRequest): Promise<void>;
+export declare function handleSupersedePolicy(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleClosePolicy(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetPolicy(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=policies.d.ts.map

package/dist/server/routes/policies.js

@@ -1,25 +1,24 @@
 // /v1/policies routes.
-import { closePolicy, loadPolicies, loadPoliciesAsOf, loadPolicyById, savePolicy, VALID_POLICY_STATES } from '../../policies.js';
-import { HttpError, sendJson } from '../../http-util.js';
+import { policiesAsOf, POLICY } from '../../objects/policies.js';
+import { HttpError, sendJson } from '../../util/http-util.js';
 import { buildContextWithAuth } from '../auth.js';
-import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
-import { isJsonString } from '../../json.js';
-// HTTP-boundary check for an optional policy date field (validFrom/validTo).
-// Type + length only; savePolicy/loadPoliciesAsOf normalize + format-validate the
-// value (an unparseable date throws there -> mapped to 400). 64-char cap bounds a
-// junk string before it reaches the Date parser.
-function optionalDateField(raw, label) {
-    if (raw === undefined || raw === null)
-        return undefined;
-    if (!isJsonString(raw)) {
-        throw new HttpError(400, `${label} must be a string`);
-    }
-    if (raw.length > 64) {
-        throw new HttpError(400, `${label} exceeds 64-character cap`);
-    }
-    return raw;
-}
+import { parseJsonBody } from '../validation.js';
+import { closeRoute, getRoute, listRoute, objectsOf, optionalString, requiredString, saveFor, supersedeRoute } from './object-routes.js';
+// The date fields get a type and length check only: the store parses the date, and the cap bounds a junk string before it reaches the Date parser.
+const MAX_DATE_LEN = 64;
+const policyRoutes = {
+    noun: 'policy',
+    field: 'policy',
+    listField: 'policies',
+    object: POLICY,
+    revise: (body) => {
+        const policyText = requiredString(body, 'policyText', { max: 4096 });
+        const validFrom = optionalString(body, 'validFrom', MAX_DATE_LEN);
+        const validTo = optionalString(body, 'validTo', MAX_DATE_LEN);
+        const changeSummary = optionalString(body, 'changeSummary', 4096);
+        return (existing, id) => ({ policyName: existing.policyName, policyText, validFrom, validTo, changeSummary, supersedesPolicyId: id });
+    },
+};
 // ── policies (first-class object, bi-temporal-first) ──
 //
 // 6 routes: POST /v1/policies (new; processName-style body policyName +
@@ -29,124 +28,41 @@ function optionalDateField(raw, label) {
 // /v1/policies/:id, POST /v1/policies/:id/supersede, POST /v1/policies/:id/close.
 // Date inputs are normalized + range-validated in the store; an invalid/inverted
 // date throws -> 400. DoS caps: policyName/policyText/changeSummary 4096.
-export async function handleCreatePolicy({ req, res, opts }) {
-    const ctx = await buildContextWithAuth(req, opts);
-    const body = await parseJsonBody(req, ctx);
-    const policyName = body['policyName'];
-    if (!isJsonString(policyName) || policyName.trim().length === 0) {
-        throw new HttpError(400, 'policyName is required (non-empty string)');
-    }
-    if (policyName.length > 4096) {
-        throw new HttpError(400, 'policyName exceeds 4096-character cap');
-    }
-    const policyText = body['policyText'];
-    if (!isJsonString(policyText) || policyText.trim().length === 0) {
-        throw new HttpError(400, 'policyText is required (non-empty string)');
-    }
-    if (policyText.length > 4096) {
-        throw new HttpError(400, 'policyText exceeds 4096-character cap');
-    }
-    const validFrom = optionalDateField(body['validFrom'], 'validFrom');
-    const validTo = optionalDateField(body['validTo'], 'validTo');
-    const policy = savePolicy(opts.hippoRoot, ctx.tenantId, {
-        policyName,
-        policyText,
-        validFrom,
-        validTo,
-    }, ctx.actor.subject);
-    sendJson(res, 201, { policy });
-    return;
+export async function handleCreatePolicy(rr) {
+    const ctx = await buildContextWithAuth(rr.req, rr.opts);
+    const body = await parseJsonBody(rr.req, ctx);
+    const policy = await saveFor(rr, POLICY, ctx.tenantId, ctx.actor.subject, {
+        policyName: requiredString(body, 'policyName', { max: 4096 }),
+        policyText: requiredString(body, 'policyText', { max: 4096 }),
+        validFrom: optionalString(body, 'validFrom', MAX_DATE_LEN),
+        validTo: optionalString(body, 'validTo', MAX_DATE_LEN),
+    });
+    sendJson(rr.res, 201, { policy });
 }
-export async function handleListPolicies({ req, res, opts, query }) {
-    const status = query.get('status') ?? 'all';
-    const limit = parseListLimit(query.get('limit'));
-    const after = parseCursor(query.get('cursor'), 'string', 'integer');
-    const ctx = await buildContextWithAuth(req, opts);
-    let policies;
-    if (status === 'all') {
-        policies = loadPolicies(opts.hippoRoot, ctx.tenantId, { limit: limit + 1, after });
-    }
-    else {
-        if (!isSetMember(VALID_POLICY_STATES, status)) {
-            throw new HttpError(400, `status must be one of: active | superseded | closed | all (got "${status}")`);
-        }
-        policies = loadPolicies(opts.hippoRoot, ctx.tenantId, {
-            status,
-            limit: limit + 1,
-            after,
-        });
-    }
-    const page = pageOf(policies, limit, byCreatedAt);
-    sendJson(res, 200, { policies: page.items, next_cursor: page.nextCursor });
-    return;
+export function handleListPolicies(rr) {
+    return listRoute(policyRoutes, rr);
 }
 // The as-of query: must precede the /:id GET (literal 'asof' is non-numeric so
 // the /(\d+)/ route would not match it, but order it first for clarity).
-export async function handlePoliciesAsOf({ req, res, opts, query }) {
+export async function handlePoliciesAsOf(rr) {
+    const { req, res, opts, query } = rr;
     const date = query.get('date');
     if (date === null || date.length === 0) {
         throw new HttpError(400, 'date is required (ISO-8601 valid-time)');
     }
     const name = query.get('name') ?? undefined;
     const ctx = await buildContextWithAuth(req, opts);
-    const policies = loadPoliciesAsOf(opts.hippoRoot, ctx.tenantId, date, { name });
+    const policies = await policiesAsOf(objectsOf(rr), ctx.tenantId, date, { name });
     sendJson(res, 200, { policies });
     return;
 }
-export async function handleSupersedePolicy({ req, res, opts }, policySupersedeMatch) {
-    const id = parseInt(policySupersedeMatch[1], 10);
-    const ctx = await buildContextWithAuth(req, opts);
-    const body = await parseJsonBody(req, ctx);
-    const policyText = body['policyText'];
-    if (!isJsonString(policyText) || policyText.trim().length === 0) {
-        throw new HttpError(400, 'policyText is required (non-empty string)');
-    }
-    if (policyText.length > 4096) {
-        throw new HttpError(400, 'policyText exceeds 4096-character cap');
-    }
-    const validFrom = optionalDateField(body['validFrom'], 'validFrom');
-    const validTo = optionalDateField(body['validTo'], 'validTo');
-    const changeRaw = body['changeSummary'];
-    let changeSummary;
-    if (changeRaw !== undefined && changeRaw !== null) {
-        if (!isJsonString(changeRaw)) {
-            throw new HttpError(400, 'changeSummary must be a string');
-        }
-        if (changeRaw.length > 4096) {
-            throw new HttpError(400, 'changeSummary exceeds 4096-character cap');
-        }
-        changeSummary = changeRaw;
-    }
-    const existing = loadPolicyById(opts.hippoRoot, ctx.tenantId, id);
-    if (!existing) {
-        throw new HttpError(404, `policy ${id} not found`);
-    }
-    const policy = savePolicy(opts.hippoRoot, ctx.tenantId, {
-        policyName: existing.policyName,
-        policyText,
-        validFrom,
-        validTo,
-        changeSummary,
-        supersedesPolicyId: id,
-    }, ctx.actor.subject);
-    sendJson(res, 200, { policy });
-    return;
+export function handleSupersedePolicy(rr, match) {
+    return supersedeRoute(policyRoutes, rr, match);
 }
-export async function handleClosePolicy({ req, res, opts }, policyCloseMatch) {
-    const id = parseInt(policyCloseMatch[1], 10);
-    const ctx = await buildContextWithAuth(req, opts);
-    const policy = closePolicy(opts.hippoRoot, ctx.tenantId, id, ctx.actor.subject);
-    sendJson(res, 200, { policy });
-    return;
+export function handleClosePolicy(rr, match) {
+    return closeRoute(policyRoutes, rr, match);
 }
-export async function handleGetPolicy({ req, res, opts }, policyByIdMatch) {
-    const id = parseInt(policyByIdMatch[1], 10);
-    const ctx = await buildContextWithAuth(req, opts);
-    const policy = loadPolicyById(opts.hippoRoot, ctx.tenantId, id);
-    if (!policy) {
-        throw new HttpError(404, `policy ${id} not found`);
-    }
-    sendJson(res, 200, { policy });
-    return;
+export function handleGetPolicy(rr, match) {
+    return getRoute(policyRoutes, rr, match);
 }
 //# sourceMappingURL=policies.js.map

package/dist/server/routes/predictions.js

@@ -1,10 +1,12 @@
 // /v1/predictions routes.
-import { closePrediction, computePredictionBaserate, loadAllPredictions, loadOpenPredictions, loadPredictionById, loadPredictionsByClass, savePrediction, VALID_CLOSURE_STATES } from '../../predictions/store.js';
-import { HttpError, MAX_ID_LEN, sendJson } from '../../http-util.js';
+import { loadConfig } from '../../core/config.js';
+import { predictionMirror, VALID_CLOSURE_STATES } from '../../store/predictions.js';
+import { requireGroup } from '../../store/port.js';
+import { HttpError, MAX_ID_LEN, sendJson } from '../../util/http-util.js';
 import { buildContextWithAuth } from '../auth.js';
 import { byCreatedAt, pageOf, parseCursor } from '../cursor.js';
-import { isJsonNumber, isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
-import { isJsonString } from '../../json.js';
+import { isSetMember, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString, isJsonNumber } from '../../util/json.js';
 // ── prediction first-class object ──
 //
 // 4 routes: POST /v1/predictions (create), GET /v1/predictions (list),
@@ -50,48 +52,33 @@ export async function handleCreatePrediction({ req, res, opts }) {
         }
         targetDateValue = targetDate;
     }
-    const prediction = savePrediction(opts.hippoRoot, ctx.tenantId, {
-        classTag,
-        claimText: claim,
-        estimateValue,
-        estimateUnit,
-        targetDate: targetDateValue,
-    }, ctx.actor.subject);
+    const claimed = { classTag, claimText: claim, estimateValue, estimateUnit, targetDate: targetDateValue };
+    const mirror = predictionMirror(ctx.tenantId, claimed, loadConfig(opts.hippoRoot).defaultHalfLifeDays);
+    const prediction = await requireGroup(opts.store, 'predictions').savePrediction(ctx.tenantId, { ...claimed, mirror }, ctx.actor.subject);
     sendJson(res, 201, { prediction });
     return;
 }
+/** Which rows a list reads; a status other than all or open needs a class, as no store reads one closed state across classes. */
+function listFilter(classTag, status) {
+    if (status === 'all')
+        return { classTag };
+    if (status === 'open')
+        return { classTag, closureState: 'open' };
+    if (!isSetMember(VALID_CLOSURE_STATES, status)) {
+        throw new HttpError(400, `status must be one of: open | closed | closed-unknown | all (got "${status}")`);
+    }
+    if (!classTag) {
+        throw new HttpError(400, 'status filter (non-open) requires class param');
+    }
+    return { classTag, closureState: status };
+}
 export async function handleListPredictions({ req, res, opts, query }) {
-    const classTag = query.get('class') ?? undefined;
+    const classTag = query.get('class') || undefined;
     const status = query.get('status') ?? 'all';
     const limit = parseListLimit(query.get('limit'));
     const after = parseCursor(query.get('cursor'), 'string', 'integer');
     const ctx = await buildContextWithAuth(req, opts);
-    let predictions;
-    if (status === 'all') {
-        predictions = classTag
-            ? loadPredictionsByClass(opts.hippoRoot, ctx.tenantId, classTag, { limit: limit + 1, after })
-            : loadAllPredictions(opts.hippoRoot, ctx.tenantId, { limit: limit + 1, after });
-    }
-    else if (status === 'open') {
-        predictions = loadOpenPredictions(opts.hippoRoot, ctx.tenantId, {
-            classTag: classTag || undefined,
-            limit: limit + 1,
-            after,
-        });
-    }
-    else {
-        if (!isSetMember(VALID_CLOSURE_STATES, status)) {
-            throw new HttpError(400, `status must be one of: open | closed | closed-unknown | all (got "${status}")`);
-        }
-        if (!classTag) {
-            throw new HttpError(400, 'status filter (non-open) requires class param');
-        }
-        predictions = loadPredictionsByClass(opts.hippoRoot, ctx.tenantId, classTag, {
-            closureState: status,
-            limit: limit + 1,
-            after,
-        });
-    }
+    const predictions = await requireGroup(opts.store, 'predictions').listPredictions(ctx.tenantId, { ...listFilter(classTag, status), limit: limit + 1, after });
     const page = pageOf(predictions, limit, byCreatedAt);
     sendJson(res, 200, { predictions: page.items, next_cursor: page.nextCursor });
     return;
@@ -109,14 +96,14 @@ export async function handlePredictionStats({ req, res, opts, query }) {
         throw new HttpError(400, `class exceeds ${MAX_ID_LEN}-character cap`);
     }
     const ctx = await buildContextWithAuth(req, opts);
-    const baserate = computePredictionBaserate(opts.hippoRoot, ctx.tenantId, classTag, ctx.actor.subject);
+    const baserate = await requireGroup(opts.store, 'predictions').predictionBaserate(ctx.tenantId, classTag, ctx.actor.subject);
     sendJson(res, 200, { baserate });
     return;
 }
 export async function handleGetPrediction({ req, res, opts }, predictionByIdMatch) {
     const id = parseInt(predictionByIdMatch[1], 10);
     const ctx = await buildContextWithAuth(req, opts);
-    const prediction = loadPredictionById(opts.hippoRoot, ctx.tenantId, id);
+    const prediction = await requireGroup(opts.store, 'predictions').predictionById(ctx.tenantId, id);
     if (!prediction) {
         throw new HttpError(404, `prediction ${id} not found`);
     }
@@ -150,11 +137,8 @@ export async function handleClosePrediction({ req, res, opts }, predictionCloseM
         }
         closureNote = note;
     }
-    const prediction = closePrediction(opts.hippoRoot, ctx.tenantId, id, {
-        closureState: state,
-        actualValue,
-        closureNote,
-    }, ctx.actor.subject);
+    const close = { closureState: state, actualValue, closureNote };
+    const prediction = await requireGroup(opts.store, 'predictions').closePrediction(ctx.tenantId, id, close, ctx.actor.subject);
     sendJson(res, 200, { prediction });
     return;
 }

package/dist/server/routes/processes.d.ts

@@ -1,7 +1,7 @@
 import type { RouteRequest } from '../types.js';
-export declare function handleCreateProcess({ req, res, opts }: RouteRequest): Promise<void>;
-export declare function handleListProcesses({ req, res, opts, query }: RouteRequest): Promise<void>;
-export declare function handleSupersedeProcess({ req, res, opts }: RouteRequest, processSupersedeMatch: RegExpMatchArray): Promise<void>;
-export declare function handleCloseProcess({ req, res, opts }: RouteRequest, processCloseMatch: RegExpMatchArray): Promise<void>;
-export declare function handleGetProcess({ req, res, opts }: RouteRequest, processByIdMatch: RegExpMatchArray): Promise<void>;
+export declare function handleCreateProcess(rr: RouteRequest): Promise<void>;
+export declare function handleListProcesses(rr: RouteRequest): Promise<void>;
+export declare function handleSupersedeProcess(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCloseProcess(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetProcess(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=processes.d.ts.map