hippo-memory 1.72.0 → 2.1.0

package/dist/objects/decisions.js

@@ -1,10 +1,13 @@
-/** Decision object: the `decisions` table is the source of truth, so an in-force decision stays `active` despite memory decay.
- *  The memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall only; saveDecision commits both in one `objects` transaction. */
+/**
+ * Decision object: the `decisions` table is the source of truth, so an
+ * in-force decision stays `active` despite memory decay. The memory
+ * mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall only;
+ * saveDecision commits both in one `objects` transaction.
+ */
 import { BadRequestError } from '../core/api-errors.js';
 import { writeEntry } from '../store/entry-writes.js';
 import { assertTenantId } from '../store/tenant.js';
-import { closeObjectAt, listObjectsAt, objectByIdAt, saveObjectAt } from './lifecycle.js';
-import { objectIdByMemory } from '../store/sqlite/objects-group.js';
+import { closeObject, listObjects, objectById, saveObject } from './lifecycle.js';
 const SUPERSEDED_TAG = 'superseded';
 export const VALID_DECISION_STATES = new Set([
     'active',
@@ -32,32 +35,35 @@ export const DECISION = {
 };
 /** Create a decision; the memory mirror and the row commit in one transaction.
  *  Superseding CASes the old row (WHERE status='active'), so a duplicate supersede aborts the whole write. */
-export function saveDecision(hippoRoot, tenantId, opts, actor = 'cli') {
-    return saveObjectAt(DECISION, { hippoRoot, tenantId, actor }, opts);
+export function saveDecision(objects, hippoRoot, tenantId, opts, actor = 'cli') {
+    return saveObject(objects, DECISION, { hippoRoot, tenantId, actor }, opts);
 }
-/** Weaken the memory a new decision replaces, once the save has committed: half-life halved to a day at least, marked stale, tagged `superseded`. */
+/**
+ * Weaken the memory a new decision replaces, once the save has committed: half-life halved to a day at least, marked
+ * stale, tagged `superseded`.
+ */
 export function weakenSupersededMemory(hippoRoot, entry, actor = 'cli') {
     const tags = entry.tags.includes(SUPERSEDED_TAG) ? entry.tags : [...entry.tags, SUPERSEDED_TAG];
     const halved = Math.max(1, Math.floor(entry.half_life_days / 2));
     writeEntry(hippoRoot, { ...entry, half_life_days: halved, confidence: 'stale', tags }, { actor });
 }
 /** Close (retire) an active decision with no successor; the memory mirror is not mutated. */
-export function closeDecision(hippoRoot, tenantId, id, actor = 'cli') {
-    return closeObjectAt(hippoRoot, DECISION, tenantId, id, actor);
+export function closeDecision(objects, tenantId, id, actor = 'cli') {
+    return closeObject(objects, DECISION, tenantId, id, actor);
 }
-export function loadDecisionById(hippoRoot, tenantId, id) {
-    return objectByIdAt(hippoRoot, DECISION, tenantId, id);
+export function loadDecisionById(objects, tenantId, id) {
+    return objectById(objects, DECISION, tenantId, id);
 }
-export function loadDecisions(hippoRoot, tenantId, opts = {}) {
-    return listObjectsAt(hippoRoot, DECISION, tenantId, opts);
+export function loadDecisions(objects, tenantId, opts = {}) {
+    return listObjects(objects, DECISION, tenantId, opts);
 }
-export function loadActiveDecisions(hippoRoot, tenantId, opts = {}) {
-    return loadDecisions(hippoRoot, tenantId, { status: 'active', limit: opts.limit });
+export function loadActiveDecisions(objects, tenantId, opts = {}) {
+    return loadDecisions(objects, tenantId, { status: 'active', limit: opts.limit });
 }
 /** Resolve a `--supersedes <memory-id>` to the table id of the ACTIVE decision backed by that memory, or null.
  *  Exported so the CLI's backward-compat path is testable at the store layer. */
-export function resolveActiveDecisionIdByMemory(hippoRoot, tenantId, memoryId) {
+export async function resolveActiveDecisionIdByMemory(objects, tenantId, memoryId) {
     assertTenantId('resolveActiveDecisionIdByMemory', tenantId);
-    return objectIdByMemory(hippoRoot, tenantId, 'decision', 'active', memoryId);
+    return objects.objectIdByMemory(tenantId, 'decision', 'active', memoryId);
 }
 //# sourceMappingURL=decisions.js.map

package/dist/objects/descriptor.js

@@ -1,4 +1,5 @@
-// The words and rules that differ between the typed objects (decision, project brief and the rest), held as data so one lifecycle serves every kind.
+// The words and rules that differ between the typed objects (decision, project brief and the rest), held as data so one
+// lifecycle serves every kind.
 // A kind's table, columns and audit keys sit behind the `objects` store group.
 export {};
 //# sourceMappingURL=descriptor.js.map

package/dist/objects/fields.d.ts

@@ -3,7 +3,10 @@ export interface LineMessages {
     readonly singleLine: string;
     readonly tooLong: string;
 }
-/** A one-line name such as a repo or a customer: trimmed first, because the trimmed value is what gets stored and matched. */
+/**
+ * A one-line name such as a repo or a customer: trimmed first, because the trimmed value is what gets stored and
+ * matched.
+ */
 export declare function requireLine(value: string, max: number, m: LineMessages): string;
 export interface TextMessages {
     /** Leave out for an optional field. */

package/dist/objects/fields.js

@@ -1,6 +1,10 @@
-// Field checks the typed objects share. The module passes each error text in full, because the wording differs per type.
+// Field checks the typed objects share. The module passes each error text in full, because the wording differs per
+// type.
 import { BadRequestError } from '../core/api-errors.js';
-/** A one-line name such as a repo or a customer: trimmed first, because the trimmed value is what gets stored and matched. */
+/**
+ * A one-line name such as a repo or a customer: trimmed first, because the trimmed value is what gets stored and
+ * matched.
+ */
 export function requireLine(value, max, m) {
     const line = (value ?? '').trim();
     if (line.length === 0)

package/dist/objects/incidents.d.ts

@@ -1,6 +1,6 @@
-/** Incident object: a postmortem capsule with lifecycle open -> resolved -> closed (no supersede chain) and optional linked receipts.
- *  The `incidents` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall.
- *  linked_memory_ids must all exist in the SAME tenant or save throws before the insert. */
+/** Incident object: a postmortem capsule with lifecycle open -> resolved -> closed (no supersede chain) and optional
+ * linked receipts. The `incidents` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET
+ * NULL) is for recall. linked_memory_ids must all exist in the SAME tenant or save throws before the insert. */
 import type { KeysetPosition } from '../util/keyset.js';
 import type { ObjectDescriptor } from './descriptor.js';
 import type { Incident, IncidentStatus } from '../core/object-types.js';
@@ -24,22 +24,20 @@ export interface ListIncidentsOpts {
     after?: KeysetPosition;
 }
 export declare const INCIDENT: ObjectDescriptor<'incident'>;
-/** Opens an incident with its mirror memory (content "<text>\n\nContext: <context>" when
- * context is given) in one write; a linked memory outside the tenant refuses the whole write. */
-export declare function saveIncident(hippoRoot: string, tenantId: string, opts: SaveIncidentOpts, actor?: string): Incident;
-/** `saveIncident` over a served store's group. */
+/** Opens an incident with its mirror memory (content "<text>
+
+Context: <context>" when context is given) in one write; a linked memory outside the tenant refuses the whole write. */
 export declare function openIncident(objects: Objects, hippoRoot: string, tenantId: string, opts: SaveIncidentOpts, actor: string): Promise<Incident>;
-/** Moves an open incident to resolved and keeps it on record; a missing incident and one that is not open are told apart. */
-export declare function resolveIncident(hippoRoot: string, tenantId: string, id: number, resolutionText: string, actor?: string): Incident;
-/** `resolveIncident` over a served store's group. */
+/** Moves an open incident to resolved and keeps it on record;
+ * a missing incident and one that is not open are told apart. */
 export declare function resolveOpenIncident(objects: Objects, tenantId: string, id: number, resolutionText: string, actor: string): Promise<Incident>;
 /** Close (retire) an incident from open or resolved; sets closed_at only, the memory mirror is not mutated. */
-export declare function closeIncident(hippoRoot: string, tenantId: string, id: number, actor?: string): Incident;
-export declare function loadIncidentById(hippoRoot: string, tenantId: string, id: number): Incident | null;
-export declare function loadIncidents(hippoRoot: string, tenantId: string, opts?: ListIncidentsOpts): Incident[];
-export declare function loadOpenIncidents(hippoRoot: string, tenantId: string, opts?: {
+export declare function closeIncident(objects: Objects, tenantId: string, id: number, actor?: string): Promise<Incident>;
+export declare function loadIncidentById(objects: Objects, tenantId: string, id: number): Promise<Incident | null>;
+export declare function loadIncidents(objects: Objects, tenantId: string, opts?: ListIncidentsOpts): Promise<Incident[]>;
+export declare function loadOpenIncidents(objects: Objects, tenantId: string, opts?: {
     limit?: number;
-}): Incident[];
+}): Promise<Incident[]>;
 /** Resolve a memory id to the table id of the OPEN incident backed by it, or null; exported for store-layer tests. */
-export declare function resolveActiveIncidentIdByMemory(hippoRoot: string, tenantId: string, memoryId: string): number | null;
+export declare function resolveActiveIncidentIdByMemory(objects: Objects, tenantId: string, memoryId: string): Promise<number | null>;
 //# sourceMappingURL=incidents.d.ts.map

package/dist/objects/incidents.js

@@ -1,11 +1,10 @@
-/** Incident object: a postmortem capsule with lifecycle open -> resolved -> closed (no supersede chain) and optional linked receipts.
- *  The `incidents` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall.
- *  linked_memory_ids must all exist in the SAME tenant or save throws before the insert. */
+/** Incident object: a postmortem capsule with lifecycle open -> resolved -> closed (no supersede chain) and optional
+ * linked receipts. The `incidents` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET
+ * NULL) is for recall. linked_memory_ids must all exist in the SAME tenant or save throws before the insert. */
 import { BadRequestError, ConflictError, NotFoundError } from '../core/api-errors.js';
 import { assertTenantId } from '../store/tenant.js';
-import { closeObjectAt, listObjectsAt, objectByIdAt, objectMirror } from './lifecycle.js';
-import { isObjectRefusal } from '../store/port.js';
-import { objectIdByMemory, sqliteObjects } from '../store/sqlite/objects-group.js';
+import { closeObject, listObjects, objectById, objectMirror } from './lifecycle.js';
+import { isObjectRefusal, } from '../store/port.js';
 export const VALID_INCIDENT_STATES = new Set([
     'open',
     'resolved',
@@ -31,23 +30,25 @@ function incidentOpen(hippoRoot, tenantId, opts, actor) {
         ? `${opts.incidentText}\n\nContext: ${opts.context}`
         : opts.incidentText;
     const mirror = objectMirror(hippoRoot, tenantId, 'incident', { content, tags: opts.extraTags ?? [] });
-    const fields = { incidentText: opts.incidentText, context: opts.context ?? undefined, linkedMemoryIds: opts.linkedMemoryIds ?? [] };
+    const fields = {
+        incidentText: opts.incidentText,
+        context: opts.context ?? undefined,
+        linkedMemoryIds: opts.linkedMemoryIds ?? [],
+    };
     return { mirror, fields, actor, at };
 }
 function opened(tenantId, written) {
     if (!('refused' in written))
         return written;
     // A linked id of another tenant reads as missing, so an unverifiable receipt is never recorded.
-    if (written.refused === 'unlinked')
+    if (written.refused === 'unlinked') {
         throw new NotFoundError(`saveIncident: linked memory ${written.memoryId} not found for tenant ${tenantId}`);
+    }
     throw new Error('saveIncident: failed to reload saved incident row');
 }
-/** Opens an incident with its mirror memory (content "<text>\n\nContext: <context>" when
- * context is given) in one write; a linked memory outside the tenant refuses the whole write. */
-export function saveIncident(hippoRoot, tenantId, opts, actor = 'cli') {
-    return opened(tenantId, sqliteObjects(hippoRoot).openIncident(tenantId, incidentOpen(hippoRoot, tenantId, opts, actor)));
-}
-/** `saveIncident` over a served store's group. */
+/** Opens an incident with its mirror memory (content "<text>
+
+Context: <context>" when context is given) in one write; a linked memory outside the tenant refuses the whole write. */
 export async function openIncident(objects, hippoRoot, tenantId, opts, actor) {
     return opened(tenantId, await objects.openIncident(tenantId, incidentOpen(hippoRoot, tenantId, opts, actor)));
 }
@@ -61,36 +62,34 @@ function resolving(tenantId, resolutionText, actor) {
 function resolved(tenantId, id, written) {
     if (!isObjectRefusal(written))
         return written;
-    if (written.refused === 'missing')
+    if (written.refused === 'missing') {
         throw new NotFoundError(`resolveIncident: incident ${id} not found for tenant ${tenantId}`);
+    }
     if (written.refused !== 'status')
         throw new NotFoundError(`resolveIncident: incident ${id} not found after UPDATE`);
     throw new ConflictError(`resolveIncident: incident ${id} is not open (status='${written.status}'); only open incidents can be resolved.`);
 }
-/** Moves an open incident to resolved and keeps it on record; a missing incident and one that is not open are told apart. */
-export function resolveIncident(hippoRoot, tenantId, id, resolutionText, actor = 'cli') {
-    return resolved(tenantId, id, sqliteObjects(hippoRoot).resolveIncident(tenantId, id, resolving(tenantId, resolutionText, actor)));
-}
-/** `resolveIncident` over a served store's group. */
+/** Moves an open incident to resolved and keeps it on record;
+ * a missing incident and one that is not open are told apart. */
 export async function resolveOpenIncident(objects, tenantId, id, resolutionText, actor) {
     return resolved(tenantId, id, await objects.resolveIncident(tenantId, id, resolving(tenantId, resolutionText, actor)));
 }
 /** Close (retire) an incident from open or resolved; sets closed_at only, the memory mirror is not mutated. */
-export function closeIncident(hippoRoot, tenantId, id, actor = 'cli') {
-    return closeObjectAt(hippoRoot, INCIDENT, tenantId, id, actor);
+export function closeIncident(objects, tenantId, id, actor = 'cli') {
+    return closeObject(objects, INCIDENT, tenantId, id, actor);
 }
-export function loadIncidentById(hippoRoot, tenantId, id) {
-    return objectByIdAt(hippoRoot, INCIDENT, tenantId, id);
+export function loadIncidentById(objects, tenantId, id) {
+    return objectById(objects, INCIDENT, tenantId, id);
 }
-export function loadIncidents(hippoRoot, tenantId, opts = {}) {
-    return listObjectsAt(hippoRoot, INCIDENT, tenantId, opts);
+export function loadIncidents(objects, tenantId, opts = {}) {
+    return listObjects(objects, INCIDENT, tenantId, opts);
 }
-export function loadOpenIncidents(hippoRoot, tenantId, opts = {}) {
-    return loadIncidents(hippoRoot, tenantId, { status: 'open', limit: opts.limit });
+export function loadOpenIncidents(objects, tenantId, opts = {}) {
+    return loadIncidents(objects, tenantId, { status: 'open', limit: opts.limit });
 }
 /** Resolve a memory id to the table id of the OPEN incident backed by it, or null; exported for store-layer tests. */
-export function resolveActiveIncidentIdByMemory(hippoRoot, tenantId, memoryId) {
+export async function resolveActiveIncidentIdByMemory(objects, tenantId, memoryId) {
     assertTenantId('resolveActiveIncidentIdByMemory', tenantId);
-    return objectIdByMemory(hippoRoot, tenantId, 'incident', 'open', memoryId);
+    return objects.objectIdByMemory(tenantId, 'incident', 'open', memoryId);
 }
 //# sourceMappingURL=incidents.js.map

package/dist/objects/lifecycle.d.ts

@@ -3,12 +3,9 @@ import type { ObjectByKind, ObjectKind, SavableKind } from '../core/object-types
 import { type Objects } from '../store/port.js';
 import type { ObjectDescriptor, ObjectListOpts, SavableDescriptor } from './descriptor.js';
 /** Newest first. */
-export declare function listObjectsAt<K extends ObjectKind>(hippoRoot: string, d: ObjectDescriptor<K>, tenantId: string, opts: ObjectListOpts<K>): ObjectByKind[K][];
 export declare function listObjects<K extends ObjectKind>(objects: Objects, d: ObjectDescriptor<K>, tenantId: string, opts: ObjectListOpts<K>): Promise<ObjectByKind[K][]>;
-export declare function objectByIdAt<K extends ObjectKind>(hippoRoot: string, d: ObjectDescriptor<K>, tenantId: string, id: number): ObjectByKind[K] | null;
 export declare function objectById<K extends ObjectKind>(objects: Objects, d: ObjectDescriptor<K>, tenantId: string, id: number): Promise<ObjectByKind[K] | null>;
 /** Retires one object; its mirror memory stays as saved. */
-export declare function closeObjectAt<K extends ObjectKind>(hippoRoot: string, d: ObjectDescriptor<K>, tenantId: string, id: number, actor: string): ObjectByKind[K];
 export declare function closeObject<K extends ObjectKind>(objects: Objects, d: ObjectDescriptor<K>, tenantId: string, id: number, actor: string): Promise<ObjectByKind[K]>;
 /** The memory a typed object writes beside its row, so recall finds the object. */
 export declare function objectMirror(hippoRoot: string, tenantId: string, source: ObjectKind, text: {
@@ -22,6 +19,5 @@ export interface ObjectSaveSite {
     readonly actor: string;
 }
 /** Creates an object, or the version that replaces the one its options name, with its mirror memory in one write. */
-export declare function saveObjectAt<K extends SavableKind, W>(d: SavableDescriptor<K, W>, site: ObjectSaveSite, opts: W): ObjectByKind[K];
 export declare function saveObject<K extends SavableKind, W>(objects: Objects, d: SavableDescriptor<K, W>, site: ObjectSaveSite, opts: W): Promise<ObjectByKind[K]>;
 //# sourceMappingURL=lifecycle.d.ts.map

package/dist/objects/lifecycle.js

@@ -1,12 +1,12 @@
-// Save, close, load-by-id and list for every typed object: the checks, the mirror memory and the error text, over the `objects` store group.
-// Each flow is written twice over the same steps: `...At` answers at once on hippo.db for the CLI, and the other awaits a served store's group for the routes.
-// The tenant, the fields and the list status are checked first, so a bad request fails before a store is asked.
+// Save, close, load-by-id and list for every typed object: the checks, the mirror memory and the error text, over the
+// `objects` store group. Each flow runs once, over the `objects` group of whatever store the caller holds: the CLI's, a
+// served one, or a test's. The tenant, the fields and the list status are checked first, so a bad request fails before
+// a store is asked.
 import { DEFAULT_LIST_LIMIT } from '../util/limits.js';
 import { BadRequestError, ConflictError, NotFoundError } from '../core/api-errors.js';
 import { loadConfig } from '../core/config.js';
 import { createMemory, Layer } from '../core/memory.js';
-import { isObjectRefusal } from '../store/port.js';
-import { sqliteObjects } from '../store/sqlite/objects-group.js';
+import { isObjectRefusal, } from '../store/port.js';
 import { assertTenantId } from '../store/tenant.js';
 /** An empty status or filter lists every row, as an absent one does. */
 function listQuery(d, tenantId, opts) {
@@ -14,19 +14,17 @@ function listQuery(d, tenantId, opts) {
     if (opts.status && !d.states.has(opts.status)) {
         throw new BadRequestError(`${d.fn.list}: status must be one of ${Array.from(d.states).join('|')}; got ${opts.status}`);
     }
-    return { status: opts.status || undefined, filter: opts.filter || undefined, limit: opts.limit ?? DEFAULT_LIST_LIMIT, after: opts.after };
+    return {
+        status: opts.status || undefined,
+        filter: opts.filter || undefined,
+        limit: opts.limit ?? DEFAULT_LIST_LIMIT,
+        after: opts.after,
+    };
 }
 /** Newest first. */
-export function listObjectsAt(hippoRoot, d, tenantId, opts) {
-    return sqliteObjects(hippoRoot).listObjects(tenantId, d.kind, listQuery(d, tenantId, opts));
-}
 export async function listObjects(objects, d, tenantId, opts) {
     return objects.listObjects(tenantId, d.kind, listQuery(d, tenantId, opts));
 }
-export function objectByIdAt(hippoRoot, d, tenantId, id) {
-    assertTenantId(d.fn.get, tenantId);
-    return sqliteObjects(hippoRoot).objectById(tenantId, d.kind, id);
-}
 export async function objectById(objects, d, tenantId, id) {
     assertTenantId(d.fn.get, tenantId);
     return objects.objectById(tenantId, d.kind, id);
@@ -38,18 +36,15 @@ function closing(d, tenantId, actor) {
 function closed(d, tenantId, id, written) {
     if (!isObjectRefusal(written))
         return written;
-    if (written.refused === 'missing')
+    if (written.refused === 'missing') {
         throw new NotFoundError(`${d.fn.close}: ${d.label} ${id} not found for tenant ${tenantId}`);
+    }
     if (written.refused !== 'status')
         throw new NotFoundError(`${d.fn.close}: ${d.label} ${id} not found after UPDATE`);
     const closable = d.closableFrom.join(' or ');
     throw new ConflictError(`${d.fn.close}: ${d.label} ${id} is ${d.closeRefusal ?? `not ${closable}`} (status='${written.status}'); only ${closable} ${d.plural} can be closed.`);
 }
 /** Retires one object; its mirror memory stays as saved. */
-export function closeObjectAt(hippoRoot, d, tenantId, id, actor) {
-    const close = closing(d, tenantId, actor);
-    return closed(d, tenantId, id, sqliteObjects(hippoRoot).closeObject(tenantId, d.kind, id, close));
-}
 export async function closeObject(objects, d, tenantId, id, actor) {
     const close = closing(d, tenantId, actor);
     return closed(d, tenantId, id, await objects.closeObject(tenantId, d.kind, id, close));
@@ -67,7 +62,14 @@ export function objectMirror(hippoRoot, tenantId, source, text) {
 }
 function objectSave(site, kind, draft) {
     const mirror = objectMirror(site.hippoRoot, site.tenantId, kind, draft);
-    return { mirror, fields: draft.fields, supersedesId: draft.supersedesId, changeSummary: draft.changeSummary, actor: site.actor, at: draft.at };
+    return {
+        mirror,
+        fields: draft.fields,
+        supersedesId: draft.supersedesId,
+        changeSummary: draft.changeSummary,
+        actor: site.actor,
+        at: draft.at,
+    };
 }
 function saved(d, tenantId, replaced, written) {
     if (!isObjectRefusal(written))
@@ -84,11 +86,6 @@ function saved(d, tenantId, replaced, written) {
     }
 }
 /** Creates an object, or the version that replaces the one its options name, with its mirror memory in one write. */
-export function saveObjectAt(d, site, opts) {
-    assertTenantId(d.fn.save, site.tenantId);
-    const draft = d.draft(opts);
-    return saved(d, site.tenantId, draft.supersedesId, sqliteObjects(site.hippoRoot).saveObject(site.tenantId, d.kind, objectSave(site, d.kind, draft)));
-}
 export async function saveObject(objects, d, site, opts) {
     assertTenantId(d.fn.save, site.tenantId);
     const draft = d.draft(opts);

package/dist/objects/policies.d.ts

@@ -1,6 +1,6 @@
-/** Policy object: a rule in force over a valid-time range [valid_from, valid_to), evolving via supersession; `loadPoliciesAsOf` queries it.
- *  Transaction-time travel (what we believed at past system time T) is deferred. Superseding keeps the predecessor's valid-time range.
- *  All dates are normalised to ISO-8601 (`toISOString`) at the store boundary so the lexical half-open comparison is sound. */
+/** Policy object: a rule in force over a valid-time range [valid_from, valid_to), evolving via supersession;
+ *  `policiesAsOf` queries it. Transaction-time travel is deferred; superseding keeps the predecessor's range.
+ *  Dates are normalised to ISO-8601 (`toISOString`) at the store boundary, so lexical half-open comparison is sound. */
 import type { KeysetPosition } from '../util/keyset.js';
 import type { SavableDescriptor } from './descriptor.js';
 import type { Policy, PolicyStatus } from '../core/object-types.js';
@@ -38,21 +38,17 @@ export declare function validatePolicyDates(validFromRaw: string | undefined, va
 export declare const POLICY: SavableDescriptor<'policy', SavePolicyOpts>;
 /** Create a policy, or a new version superseding an existing one, in the `objects` store group's one transaction.
  *  valid_from defaults to now; valid_to must be > valid_from (validatePolicyDates). */
-export declare function savePolicy(hippoRoot: string, tenantId: string, opts: SavePolicyOpts, actor?: string): Policy;
+export declare function savePolicy(objects: Objects, hippoRoot: string, tenantId: string, opts: SavePolicyOpts, actor?: string): Promise<Policy>;
 /** Close (retire) an active policy with no successor; CAS on status='active', a superseded row is terminal. */
-export declare function closePolicy(hippoRoot: string, tenantId: string, id: number, actor?: string): Policy;
-export declare function loadPolicyById(hippoRoot: string, tenantId: string, id: number): Policy | null;
-export declare function loadPolicies(hippoRoot: string, tenantId: string, opts?: ListPoliciesOpts): Policy[];
-export declare function loadActivePolicies(hippoRoot: string, tenantId: string, opts?: {
+export declare function closePolicy(objects: Objects, tenantId: string, id: number, actor?: string): Promise<Policy>;
+export declare function loadPolicyById(objects: Objects, tenantId: string, id: number): Promise<Policy | null>;
+export declare function loadPolicies(objects: Objects, tenantId: string, opts?: ListPoliciesOpts): Promise<Policy[]>;
+export declare function loadActivePolicies(objects: Objects, tenantId: string, opts?: {
     limit?: number;
-}): Policy[];
-/** The policies in force at `asOfDate` (valid-time, half-open [valid_from, valid_to)); superseded rows still answer while the successor is not yet effective.
- *  `closed` rows are excluded; a date-only asOfDate means the END of that UTC day (23:59:59.999Z), so a policy created today shows up in "as of today". */
-export declare function loadPoliciesAsOf(hippoRoot: string, tenantId: string, asOfDate: string, opts?: {
-    name?: string;
-    limit?: number;
-}): Policy[];
-/** `loadPoliciesAsOf` over a served store's group. */
+}): Promise<Policy[]>;
+/** The policies in force at `asOfDate` (valid-time, half-open [valid_from, valid_to)); superseded rows still answer
+ *  while the successor is not yet effective. `closed` rows are excluded; a date-only asOfDate means the END of that
+ *  UTC day (23:59:59.999Z), so a policy created today shows up in "as of today". */
 export declare function policiesAsOf(objects: Objects, tenantId: string, asOfDate: string, opts?: {
     name?: string;
     limit?: number;

package/dist/objects/policies.js

@@ -1,11 +1,10 @@
-/** Policy object: a rule in force over a valid-time range [valid_from, valid_to), evolving via supersession; `loadPoliciesAsOf` queries it.
- *  Transaction-time travel (what we believed at past system time T) is deferred. Superseding keeps the predecessor's valid-time range.
- *  All dates are normalised to ISO-8601 (`toISOString`) at the store boundary so the lexical half-open comparison is sound. */
+/** Policy object: a rule in force over a valid-time range [valid_from, valid_to), evolving via supersession;
+ *  `policiesAsOf` queries it. Transaction-time travel is deferred; superseding keeps the predecessor's range.
+ *  Dates are normalised to ISO-8601 (`toISOString`) at the store boundary, so lexical half-open comparison is sound. */
 import { DEFAULT_LIST_LIMIT } from '../util/limits.js';
 import { BadRequestError } from '../core/api-errors.js';
 import { assertTenantId } from '../store/tenant.js';
-import { closeObjectAt, listObjectsAt, objectByIdAt, saveObjectAt } from './lifecycle.js';
-import { sqliteObjects } from '../store/sqlite/objects-group.js';
+import { closeObject, listObjects, objectById, saveObject } from './lifecycle.js';
 export const VALID_POLICY_STATES = new Set([
     'active',
     'superseded',
@@ -66,28 +65,25 @@ export const POLICY = {
 };
 /** Create a policy, or a new version superseding an existing one, in the `objects` store group's one transaction.
  *  valid_from defaults to now; valid_to must be > valid_from (validatePolicyDates). */
-export function savePolicy(hippoRoot, tenantId, opts, actor = 'cli') {
-    return saveObjectAt(POLICY, { hippoRoot, tenantId, actor }, opts);
+export function savePolicy(objects, hippoRoot, tenantId, opts, actor = 'cli') {
+    return saveObject(objects, POLICY, { hippoRoot, tenantId, actor }, opts);
 }
 /** Close (retire) an active policy with no successor; CAS on status='active', a superseded row is terminal. */
-export function closePolicy(hippoRoot, tenantId, id, actor = 'cli') {
-    return closeObjectAt(hippoRoot, POLICY, tenantId, id, actor);
+export function closePolicy(objects, tenantId, id, actor = 'cli') {
+    return closeObject(objects, POLICY, tenantId, id, actor);
 }
-export function loadPolicyById(hippoRoot, tenantId, id) {
-    return objectByIdAt(hippoRoot, POLICY, tenantId, id);
+export function loadPolicyById(objects, tenantId, id) {
+    return objectById(objects, POLICY, tenantId, id);
 }
-export function loadPolicies(hippoRoot, tenantId, opts = {}) {
-    return listObjectsAt(hippoRoot, POLICY, tenantId, opts);
+export function loadPolicies(objects, tenantId, opts = {}) {
+    return listObjects(objects, POLICY, tenantId, opts);
 }
-export function loadActivePolicies(hippoRoot, tenantId, opts = {}) {
-    return loadPolicies(hippoRoot, tenantId, { status: 'active', limit: opts.limit });
+export function loadActivePolicies(objects, tenantId, opts = {}) {
+    return loadPolicies(objects, tenantId, { status: 'active', limit: opts.limit });
 }
-/** The policies in force at `asOfDate` (valid-time, half-open [valid_from, valid_to)); superseded rows still answer while the successor is not yet effective.
- *  `closed` rows are excluded; a date-only asOfDate means the END of that UTC day (23:59:59.999Z), so a policy created today shows up in "as of today". */
-export function loadPoliciesAsOf(hippoRoot, tenantId, asOfDate, opts = {}) {
-    return sqliteObjects(hippoRoot).policiesInForce(tenantId, inForceQuery(tenantId, asOfDate, opts));
-}
-/** `loadPoliciesAsOf` over a served store's group. */
+/** The policies in force at `asOfDate` (valid-time, half-open [valid_from, valid_to)); superseded rows still answer
+ *  while the successor is not yet effective. `closed` rows are excluded; a date-only asOfDate means the END of that
+ *  UTC day (23:59:59.999Z), so a policy created today shows up in "as of today". */
 export async function policiesAsOf(objects, tenantId, asOfDate, opts = {}) {
     return objects.policiesInForce(tenantId, inForceQuery(tenantId, asOfDate, opts));
 }

package/dist/objects/processes.d.ts

@@ -1,7 +1,11 @@
-/** Process object: a named, ordered list of `steps` that evolves by supersession, each version recording `change_summary` and a server-derived `version`.
- *  The `processes` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall.
+/**
+ * Process object: a named, ordered list of `steps` that evolves by supersession, each version recording
+ * `change_summary` and a server-derived `version`.
+ * The `processes` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for
+ * recall.
  *  Structural step-diffing is a deferred read-side feature; the version chain is the changelog. */
 import type { KeysetPosition } from '../util/keyset.js';
+import type { Objects } from '../store/port.js';
 import { type JsonValue } from '../util/json.js';
 import type { SavableDescriptor } from './descriptor.js';
 import type { Process, ProcessStatus } from '../core/object-types.js';
@@ -30,14 +34,16 @@ export interface ListProcessesOpts {
 /** Validate and trim the steps body; throws on a non-array, a non-string or empty element, or a cap breach. */
 export declare function validateProcessSteps(steps: JsonValue): string[];
 export declare const PROCESS: SavableDescriptor<'process', SaveProcessOpts>;
-/** Create a process, or a new version superseding an existing one, in the `objects` store group's one transaction.
- *  The supersede CAS (WHERE status='active' AND id != <new id>) throws on changes===0 so a duplicate supersede aborts the write. */
-export declare function saveProcess(hippoRoot: string, tenantId: string, opts: SaveProcessOpts, actor?: string): Process;
+/** Create a process, or a new version superseding an existing one, in the `objects`
+ * store group's one transaction. The supersede CAS (WHERE status='active' AND id
+ * != <new id>) throws on changes===0 so a duplicate supersede aborts the write.
+ */
+export declare function saveProcess(objects: Objects, hippoRoot: string, tenantId: string, opts: SaveProcessOpts, actor?: string): Promise<Process>;
 /** Close (retire) an active process with no successor; a superseded row cannot be closed. */
-export declare function closeProcess(hippoRoot: string, tenantId: string, id: number, actor?: string): Process;
-export declare function loadProcessById(hippoRoot: string, tenantId: string, id: number): Process | null;
-export declare function loadProcesses(hippoRoot: string, tenantId: string, opts?: ListProcessesOpts): Process[];
-export declare function loadActiveProcesses(hippoRoot: string, tenantId: string, opts?: {
+export declare function closeProcess(objects: Objects, tenantId: string, id: number, actor?: string): Promise<Process>;
+export declare function loadProcessById(objects: Objects, tenantId: string, id: number): Promise<Process | null>;
+export declare function loadProcesses(objects: Objects, tenantId: string, opts?: ListProcessesOpts): Promise<Process[]>;
+export declare function loadActiveProcesses(objects: Objects, tenantId: string, opts?: {
     limit?: number;
-}): Process[];
+}): Promise<Process[]>;
 //# sourceMappingURL=processes.d.ts.map

package/dist/objects/processes.js

@@ -1,9 +1,12 @@
-/** Process object: a named, ordered list of `steps` that evolves by supersession, each version recording `change_summary` and a server-derived `version`.
- *  The `processes` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall.
+/**
+ * Process object: a named, ordered list of `steps` that evolves by supersession, each version recording
+ * `change_summary` and a server-derived `version`.
+ * The `processes` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for
+ * recall.
  *  Structural step-diffing is a deferred read-side feature; the version chain is the changelog. */
 import { BadRequestError } from '../core/api-errors.js';
 import { isJsonString } from '../util/json.js';
-import { closeObjectAt, listObjectsAt, objectByIdAt, saveObjectAt } from './lifecycle.js';
+import { closeObject, listObjects, objectById, saveObject } from './lifecycle.js';
 export const VALID_PROCESS_STATES = new Set([
     'active',
     'superseded',
@@ -71,22 +74,24 @@ export const PROCESS = {
         };
     },
 };
-/** Create a process, or a new version superseding an existing one, in the `objects` store group's one transaction.
- *  The supersede CAS (WHERE status='active' AND id != <new id>) throws on changes===0 so a duplicate supersede aborts the write. */
-export function saveProcess(hippoRoot, tenantId, opts, actor = 'cli') {
-    return saveObjectAt(PROCESS, { hippoRoot, tenantId, actor }, opts);
+/** Create a process, or a new version superseding an existing one, in the `objects`
+ * store group's one transaction. The supersede CAS (WHERE status='active' AND id
+ * != <new id>) throws on changes===0 so a duplicate supersede aborts the write.
+ */
+export function saveProcess(objects, hippoRoot, tenantId, opts, actor = 'cli') {
+    return saveObject(objects, PROCESS, { hippoRoot, tenantId, actor }, opts);
 }
 /** Close (retire) an active process with no successor; a superseded row cannot be closed. */
-export function closeProcess(hippoRoot, tenantId, id, actor = 'cli') {
-    return closeObjectAt(hippoRoot, PROCESS, tenantId, id, actor);
+export function closeProcess(objects, tenantId, id, actor = 'cli') {
+    return closeObject(objects, PROCESS, tenantId, id, actor);
 }
-export function loadProcessById(hippoRoot, tenantId, id) {
-    return objectByIdAt(hippoRoot, PROCESS, tenantId, id);
+export function loadProcessById(objects, tenantId, id) {
+    return objectById(objects, PROCESS, tenantId, id);
 }
-export function loadProcesses(hippoRoot, tenantId, opts = {}) {
-    return listObjectsAt(hippoRoot, PROCESS, tenantId, opts);
+export function loadProcesses(objects, tenantId, opts = {}) {
+    return listObjects(objects, PROCESS, tenantId, opts);
 }
-export function loadActiveProcesses(hippoRoot, tenantId, opts = {}) {
-    return loadProcesses(hippoRoot, tenantId, { status: 'active', limit: opts.limit });
+export function loadActiveProcesses(objects, tenantId, opts = {}) {
+    return loadProcesses(objects, tenantId, { status: 'active', limit: opts.limit });
 }
 //# sourceMappingURL=processes.js.map