hippo-memory 1.69.0 → 1.71.0

package/dist/server/routes/policies.js

@@ -1,152 +1,60 @@
 // /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 { MAX_SHORT_FIELD_LEN, parseJsonBody } from '../validation.js';
+import { objectsOf, saveFor } from '../../api/objects.js';
+import { closeRoute, getRoute, listRoute, optionalString, requiredString, 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: MAX_SHORT_FIELD_LEN });
+        const validFrom = optionalString(body, 'validFrom', MAX_DATE_LEN);
+        const validTo = optionalString(body, 'validTo', MAX_DATE_LEN);
+        const changeSummary = optionalString(body, 'changeSummary', MAX_SHORT_FIELD_LEN);
+        return (existing, id) => ({ policyName: existing.policyName, policyText, validFrom, validTo, changeSummary, supersedesPolicyId: id });
+    },
+};
+// The as-of route is registered BEFORE /:id so the literal 'asof' is matched first; date errors surface as 400.
+export async function handleCreatePolicy(rr) {
+    const ctx = await buildContextWithAuth(rr.req, rr.opts);
+    const body = await parseJsonBody(rr.req, ctx);
+    const policy = await saveFor(ctx, POLICY, {
+        policyName: requiredString(body, 'policyName', { max: MAX_SHORT_FIELD_LEN }),
+        policyText: requiredString(body, 'policyText', { max: MAX_SHORT_FIELD_LEN }),
+        validFrom: optionalString(body, 'validFrom', MAX_DATE_LEN),
+        validTo: optionalString(body, 'validTo', MAX_DATE_LEN),
+    });
+    sendJson(rr.res, 201, { policy });
 }
-// ── policies (first-class object, bi-temporal-first) ──
-//
-// 6 routes: POST /v1/policies (new; processName-style body policyName +
-// policyText + validFrom? + validTo?), GET /v1/policies (list, status filter),
-// GET /v1/policies/asof (date + optional name; the bi-temporal as-of query;
-// placed BEFORE the /:id GET so the literal 'asof' is matched first), GET
-// /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 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(ctx), 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,17 +1,14 @@
 // /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 { closePrediction, listPredictions, predictionBaserate, predictionById, savePrediction } from '../../api/predictions.js';
+import { loadConfig } from '../../core/config.js';
+import { predictionMirror, VALID_CLOSURE_STATES } from '../../store/predictions.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';
-// ── prediction first-class object ──
-//
-// 4 routes: POST /v1/predictions (create), GET /v1/predictions (list),
-// GET /v1/predictions/:id (show), POST /v1/predictions/:id/close (close).
-// All Bearer-authed + tenant-scoped via buildContextWithAuth. closure_state
-// validated against VALID_CLOSURE_STATES (3 states). DoS caps on claim
-// (4096 chars) + closureNote (2048 chars).
+import { isSetMember, MAX_SHORT_FIELD_LEN, parseJsonBody, parseListLimit } from '../validation.js';
+import { isJsonString, isJsonNumber } from '../../util/json.js';
+// Routes: /v1/predictions (create, list, show, close), Bearer-authed and tenant-scoped; closure_state is validated against VALID_CLOSURE_STATES.
+// DoS caps: claim MAX_SHORT_FIELD_LEN chars, closureNote 2048.
 export async function handleCreatePrediction({ req, res, opts }) {
     const ctx = await buildContextWithAuth(req, opts);
     const body = await parseJsonBody(req, ctx);
@@ -19,8 +16,8 @@ export async function handleCreatePrediction({ req, res, opts }) {
     if (!isJsonString(claim) || claim.length === 0) {
         throw new HttpError(400, 'claim is required (non-empty string)');
     }
-    if (claim.length > 4096) {
-        throw new HttpError(400, 'claim exceeds 4096-character cap');
+    if (claim.length > MAX_SHORT_FIELD_LEN) {
+        throw new HttpError(400, `claim exceeds ${MAX_SHORT_FIELD_LEN}-character cap`);
     }
     const classTag = body['classTag'];
     if (!isJsonString(classTag) || classTag.length === 0) {
@@ -50,56 +47,37 @@ 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 savePrediction(ctx, { ...claimed, mirror });
     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 listPredictions(ctx, { ...listFilter(classTag, status), limit: limit + 1, after });
     const page = pageOf(predictions, limit, byCreatedAt);
     sendJson(res, 200, { predictions: page.items, next_cursor: page.nextCursor });
-    return;
 }
-// Reference-class / planning-fallacy detector.
-// Order matters: this must match BEFORE /v1/predictions/:id since 'stats'
-// is not a number — the :id regex requires \d+ so they don't conflict,
-// but routing this first avoids the dispatch order risk.
+// Reference-class / planning-fallacy detector; registered BEFORE /v1/predictions/:id so dispatch order cannot matter ('stats' is not a number, but routing
+// it first is safer).
 export async function handlePredictionStats({ req, res, opts, query }) {
     const classTag = query.get('class');
     if (!classTag || classTag.length === 0) {
@@ -109,19 +87,17 @@ 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 predictionBaserate(ctx, classTag);
     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 predictionById(ctx, id);
     if (!prediction) {
         throw new HttpError(404, `prediction ${id} not found`);
     }
     sendJson(res, 200, { prediction });
-    return;
 }
 export async function handleClosePrediction({ req, res, opts }, predictionCloseMatch) {
     const id = parseInt(predictionCloseMatch[1], 10);
@@ -150,12 +126,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 closePrediction(ctx, id, close);
     sendJson(res, 200, { prediction });
-    return;
 }
 //# sourceMappingURL=predictions.js.map

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

package/dist/server/routes/processes.js

@@ -1,21 +1,20 @@
 // /v1/processes routes.
-import { closeProcess, loadProcessById, loadProcesses, saveProcess, VALID_PROCESS_STATES } from '../../processes.js';
-import { HttpError, sendJson } from '../../http-util.js';
+import { MAX_PROCESS_STEP_LEN, MAX_PROCESS_STEPS, PROCESS } from '../../objects/processes.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 validation for a process `steps` body (untrusted). Returns the
-// step strings (saveProcess re-validates + trims, this is the fail-fast 400
-// gate). Caps mirror src/processes.ts MAX_PROCESS_STEPS / MAX_PROCESS_STEP_LEN.
+import { MAX_SHORT_FIELD_LEN, parseJsonBody } from '../validation.js';
+import { isJsonString } from '../../util/json.js';
+import { saveFor } from '../../api/objects.js';
+import { closeRoute, getRoute, listRoute, optionalString, requiredString, supersedeRoute } from './object-routes.js';
+// HTTP-boundary validation for an untrusted process `steps` body; saveProcess re-validates and trims, this is the fail-fast 400 gate.
 function validateProcessStepsBody(raw) {
     if (raw === undefined || raw === null)
         return [];
     if (!Array.isArray(raw)) {
         throw new HttpError(400, 'steps must be an array of strings');
     }
-    if (raw.length > 200) {
-        throw new HttpError(400, 'steps exceeds 200-step cap');
+    if (raw.length > MAX_PROCESS_STEPS) {
+        throw new HttpError(400, `steps exceeds ${MAX_PROCESS_STEPS}-step cap`);
     }
     for (const item of raw) {
         if (!isJsonString(item)) {
@@ -24,139 +23,50 @@ function validateProcessStepsBody(raw) {
         if (item.trim().length === 0) {
             throw new HttpError(400, 'a step is empty');
         }
-        if (item.length > 2000) {
-            throw new HttpError(400, 'a step exceeds the 2000-character cap');
+        if (item.length > MAX_PROCESS_STEP_LEN) {
+            throw new HttpError(400, `a step exceeds the ${MAX_PROCESS_STEP_LEN}-character cap`);
         }
     }
     // SAFETY: every item in raw was confirmed to be a string in the loop above.
     return raw;
 }
-// ── processes (first-class object) ──
-//
-// 5 routes: POST /v1/processes (new; body processName + steps[] + description),
-// GET /v1/processes (list, status filter), GET /v1/processes/:id (show),
-// POST /v1/processes/:id/supersede (active -> superseded by a new version; body
-// steps[] + changeSummary + description; reuses the predecessor's name),
-// POST /v1/processes/:id/close (active -> closed). Bearer-authed + tenant-scoped
-// via buildContextWithAuth. status validated against VALID_PROCESS_STATES. DoS
-// caps: processName/description/changeSummary 4096, steps 200x2000
-// (validateProcessStepsBody). Mirrors /v1/decisions; the delta lifecycle is the
-// decision supersede path.
-export async function handleCreateProcess({ req, res, opts }) {
-    const ctx = await buildContextWithAuth(req, opts);
-    const body = await parseJsonBody(req, ctx);
-    const processName = body['processName'];
-    if (!isJsonString(processName) || processName.trim().length === 0) {
-        throw new HttpError(400, 'processName is required (non-empty string)');
-    }
-    if (processName.length > 4096) {
-        throw new HttpError(400, 'processName exceeds 4096-character cap');
-    }
-    const steps = validateProcessStepsBody(body['steps']);
-    const descriptionRaw = body['description'];
-    let description;
-    if (descriptionRaw !== undefined && descriptionRaw !== null) {
-        if (!isJsonString(descriptionRaw)) {
-            throw new HttpError(400, 'description must be a string');
+const processRoutes = {
+    noun: 'process',
+    field: 'process',
+    listField: 'processes',
+    object: PROCESS,
+    revise: (body) => {
+        const steps = validateProcessStepsBody(body['steps']);
+        if (steps.length === 0) {
+            throw new HttpError(400, 'steps is required (at least one step) for a supersession');
         }
-        if (descriptionRaw.length > 4096) {
-            throw new HttpError(400, 'description exceeds 4096-character cap');
-        }
-        description = descriptionRaw;
-    }
-    const process = saveProcess(opts.hippoRoot, ctx.tenantId, {
-        processName,
-        steps,
-        description,
-    }, ctx.actor.subject);
-    sendJson(res, 201, { process });
-    return;
+        const changeSummary = optionalString(body, 'changeSummary', MAX_SHORT_FIELD_LEN);
+        const description = optionalString(body, 'description', MAX_SHORT_FIELD_LEN);
+        return (existing, id) => ({ processName: existing.processName, steps, description, changeSummary, supersedesProcessId: id });
+    },
+};
+// Routes: /v1/processes (create, list, show, supersede, close), mirroring /v1/decisions; supersede creates a new version that reuses the predecessor's name.
+// DoS caps: processName/description/changeSummary MAX_SHORT_FIELD_LEN, steps MAX_PROCESS_STEPS x MAX_PROCESS_STEP_LEN (validateProcessStepsBody).
+export async function handleCreateProcess(rr) {
+    const ctx = await buildContextWithAuth(rr.req, rr.opts);
+    const body = await parseJsonBody(rr.req, ctx);
+    const process = await saveFor(ctx, PROCESS, {
+        processName: requiredString(body, 'processName', { max: MAX_SHORT_FIELD_LEN }),
+        steps: validateProcessStepsBody(body['steps']),
+        description: optionalString(body, 'description', MAX_SHORT_FIELD_LEN),
+    });
+    sendJson(rr.res, 201, { process });
 }
-export async function handleListProcesses({ 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 processes;
-    if (status === 'all') {
-        processes = loadProcesses(opts.hippoRoot, ctx.tenantId, { limit: limit + 1, after });
-    }
-    else {
-        if (!isSetMember(VALID_PROCESS_STATES, status)) {
-            throw new HttpError(400, `status must be one of: active | superseded | closed | all (got "${status}")`);
-        }
-        processes = loadProcesses(opts.hippoRoot, ctx.tenantId, {
-            status,
-            limit: limit + 1,
-            after,
-        });
-    }
-    const page = pageOf(processes, limit, byCreatedAt);
-    sendJson(res, 200, { processes: page.items, next_cursor: page.nextCursor });
-    return;
+export function handleListProcesses(rr) {
+    return listRoute(processRoutes, rr);
 }
-export async function handleSupersedeProcess({ req, res, opts }, processSupersedeMatch) {
-    const id = parseInt(processSupersedeMatch[1], 10);
-    const ctx = await buildContextWithAuth(req, opts);
-    const body = await parseJsonBody(req, ctx);
-    const steps = validateProcessStepsBody(body['steps']);
-    if (steps.length === 0) {
-        throw new HttpError(400, 'steps is required (at least one step) for a supersession');
-    }
-    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 descRaw = body['description'];
-    let description;
-    if (descRaw !== undefined && descRaw !== null) {
-        if (!isJsonString(descRaw)) {
-            throw new HttpError(400, 'description must be a string');
-        }
-        if (descRaw.length > 4096) {
-            throw new HttpError(400, 'description exceeds 4096-character cap');
-        }
-        description = descRaw;
-    }
-    // A supersession is a new version of the SAME process: reuse the
-    // predecessor's name. 404 if the target does not exist; saveProcess's
-    // in-SAVEPOINT preflight is the authoritative active-state check (409).
-    const existing = loadProcessById(opts.hippoRoot, ctx.tenantId, id);
-    if (!existing) {
-        throw new HttpError(404, `process ${id} not found`);
-    }
-    const process = saveProcess(opts.hippoRoot, ctx.tenantId, {
-        processName: existing.processName,
-        steps,
-        description,
-        changeSummary,
-        supersedesProcessId: id,
-    }, ctx.actor.subject);
-    sendJson(res, 200, { process });
-    return;
+export function handleSupersedeProcess(rr, match) {
+    return supersedeRoute(processRoutes, rr, match);
 }
-export async function handleCloseProcess({ req, res, opts }, processCloseMatch) {
-    const id = parseInt(processCloseMatch[1], 10);
-    const ctx = await buildContextWithAuth(req, opts);
-    const process = closeProcess(opts.hippoRoot, ctx.tenantId, id, ctx.actor.subject);
-    sendJson(res, 200, { process });
-    return;
+export function handleCloseProcess(rr, match) {
+    return closeRoute(processRoutes, rr, match);
 }
-export async function handleGetProcess({ req, res, opts }, processByIdMatch) {
-    const id = parseInt(processByIdMatch[1], 10);
-    const ctx = await buildContextWithAuth(req, opts);
-    const process = loadProcessById(opts.hippoRoot, ctx.tenantId, id);
-    if (!process) {
-        throw new HttpError(404, `process ${id} not found`);
-    }
-    sendJson(res, 200, { process });
-    return;
+export function handleGetProcess(rr, match) {
+    return getRoute(processRoutes, rr, match);
 }
 //# sourceMappingURL=processes.js.map

package/dist/server/routes/project-briefs.d.ts

@@ -1,8 +1,8 @@
 import type { RouteRequest } from '../types.js';
-export declare function handleCreateProjectBrief({ req, res, opts }: RouteRequest): Promise<void>;
-export declare function handleListProjectBriefs({ req, res, opts, query }: RouteRequest): Promise<void>;
-export declare function handleRefreshProjectBrief({ req, res, opts }: RouteRequest): Promise<void>;
-export declare function handleSupersedeProjectBrief({ req, res, opts }: RouteRequest, briefSupersedeMatch: RegExpMatchArray): Promise<void>;
-export declare function handleCloseProjectBrief({ req, res, opts }: RouteRequest, briefCloseMatch: RegExpMatchArray): Promise<void>;
-export declare function handleGetProjectBrief({ req, res, opts }: RouteRequest, briefByIdMatch: RegExpMatchArray): Promise<void>;
+export declare function handleCreateProjectBrief(rr: RouteRequest): Promise<void>;
+export declare function handleListProjectBriefs(rr: RouteRequest): Promise<void>;
+export declare function handleRefreshProjectBrief(rr: RouteRequest): Promise<void>;
+export declare function handleSupersedeProjectBrief(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleCloseProjectBrief(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
+export declare function handleGetProjectBrief(rr: RouteRequest, match: RegExpMatchArray): Promise<void>;
 //# sourceMappingURL=project-briefs.d.ts.map