@tangleai/store 0.21.1 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # @tangleai/store
 
+## 0.25.0
+
+### Patch Changes
+
+- Enforce semantic template binding targets, monotone caps and tool subsets at admission and instantiation. Pin and capture host message adapter versions, check child graph bindings, and preserve optional no-change instantiation.
+
+  Enforce workflow concurrency through Jaren scheduling, retain failed physical request costs in durable receipts, restore switch outputs from committed branches, and preserve hierarchical message paths. Advance the runtime checkpoint ABI for the changed execution semantics.
+
+  Compose durable human waits through nested graphs, switches and loop iterations.
+  Derive interaction ids from full paths, reconcile the current reserved resume
+  segment, and reject conflicting response bytes under an existing key. Drain
+  started host lifetimes before reporting failure or suspension.
+
+  Enforce physical-request context and retained trace quotas, retain the shared
+  account's provider-total or estimated token charge, and claim-fence cumulative
+  active-time settlement across resumable segments. Quota refusals roll back the
+  attempted payload while retaining actual failure costs.
+- Updated dependencies
+  - @tangleai/mas@0.25.0
+  - @tangleai/config@0.25.0
+  - @tangleai/core@0.25.0
+  - @tangleai/documents@0.25.0
+  - @tangleai/memory@0.25.0
+  - @tangleai/outcomes@0.25.0
+
+## 0.24.1
+
+### Patch Changes
+
+- Update the Jaren foundation to 0.86.0 with exact registry and source pins. Qualify supervised Node SQLite execution, outcome replay after native backups, and physical-model authoring through the shared Data editor. Document the available relational, migration, cursor and collection-drag mechanisms and their host boundaries.
+- @tangleai/config@0.24.1
+  - @tangleai/core@0.24.1
+  - @tangleai/documents@0.24.1
+  - @tangleai/mas@0.24.1
+  - @tangleai/memory@0.24.1
+  - @tangleai/outcomes@0.24.1
+
+## 0.24.0
+
+### Minor Changes
+
+- Add the outcomes package for independently evidenced decisions, deterministic scoring, atomic confidence projection, bounded artifact refinement and explicitly approved promotion and rollback. The public operation contract, two-domain adapter kit and keyless example share the same scoped request receipts, one-use held-out gates, full head revision checks and interruption recovery.
+
+  The store adapter owns outcome records and memory changes in one SQLite transaction. The new pure confidence helper preserves fact fields; existing applyOutcome calls retain their original duplicate-citation and timestamp behavior and do not acquire a durable replay guarantee. No existing persisted memory format changes. Hosts opt into the new lifecycle, provide evidence and approval authority, and use a new artifact key for schema or policy changes. Scripted paired measurements and Node/Bun packed consumers qualify the mechanism; downstream domain integrations and automatic promotion remain separate work.
+
+### Patch Changes
+
+- Updated dependencies
+  - @tangleai/outcomes@0.24.0
+  - @tangleai/memory@0.24.0
+  - @tangleai/config@0.24.0
+  - @tangleai/core@0.24.0
+  - @tangleai/documents@0.24.0
+  - @tangleai/mas@0.24.0
+
+## 0.23.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @tangleai/memory@0.23.0
+  - @tangleai/config@0.23.0
+  - @tangleai/core@0.23.0
+  - @tangleai/documents@0.23.0
+  - @tangleai/mas@0.23.0
+
+## 0.22.0
+
+### Patch Changes
+
+- @tangleai/config@0.22.0
+  - @tangleai/core@0.22.0
+  - @tangleai/documents@0.22.0
+  - @tangleai/mas@0.22.0
+  - @tangleai/memory@0.22.0
+
 ## 0.21.1
 
 ### Patch Changes

package/README.md

@@ -5,3 +5,71 @@ Tangle AI persistence — the MemoryStore contract over SQLite via @jarenjs/db,
 Install with `npm install @tangleai/store`. The npm distribution provides ESM JavaScript, TypeScript declarations, and the documented package subpaths for Node 24 and Bun 1.4 or newer.
 
 See the [Tangle documentation](https://github.com/jklarenbeek/tangleai#readme) for architecture, examples, and runtime requirements. All public Tangle packages use one coordinated version.
+
+## Execution hosts and backups
+
+`openTangleDb` accepts the published Jaren `OpenStoreOptions`, with an optional
+driver. Its default selects the synchronous Node or Bun SQLite driver. Injected
+drivers use the same Store, transactions, memory, outcome and MAS adapters.
+
+Jaren 0.86.0 adds `nodeProcessDriver` from `@jarenjs/db/node-process`. Retain the
+opened owner and pass it through a driver adapter to `openTangleDb`; supervise
+ordinary store/service calls with `owner.supervise`. The
+[runnable Node example](../../examples/supervised-store.ts) exercises both outcome
+domains, waits for owner exit, reopens and proves zero-effect replay:
+
+```sh
+npm run store:supervised:smoke
+node examples/supervised-store.ts --db /tmp/supervised-outcomes.sqlite
+```
+
+Share one process driver per host ownership domain. A response deadline fences
+the owner; `settled()` separately reports OS exit and replacement eligibility.
+Reopen and inspect durable receipts before retrying an uncertain write. No
+automatic replay or restart is added. This host has no synchronous/live-query
+surface; importing it on Bun works, while opening refuses with `JD0003`.
+
+`db.backupTo(path)` retains the ordinary Jaren maintenance contract, including
+atomic destination replacement. Node uses online backup; Bun uses disk-backed
+VACUUM INTO without materializing the database in JavaScript. A Bun copy remains
+synchronous native work, without incremental native cancellation. Tests restore
+WAL-backed outcome receipts on both runtimes and verify zero-effect replay.
+
+Native physical schemas and migrations remain direct Jaren operations; this
+package does not convert existing collections or grant raw SQL callers outcome
+service authority. See the [integration audit](../../docs/JARENJS_INTEGRATION.md)
+for ownership, compatibility and available mechanisms.
+
+## Atomic outcome storage
+
+`createOutcomeStore(db)` implements `@tangleai/outcomes`' atomic owner over Jaren
+immediate transactions, with `outcome_records`, `outcome_keys`, `outcome_heads`
+and `outcome_operations` alongside the existing `memories` collection. Immutable
+records carry per-scope sequence values. Head activation compares version and
+revision; projection changes current memory confidence and its terminal receipt
+in the same transaction. Its `memories` property is that same owner's memory
+view, not a separately attached store.
+
+```ts
+import { openTangleDb, createOutcomeStore } from '@tangleai/store';
+const db = await openTangleDb({ path: '/tmp/outcomes.sqlite' });
+const store = createOutcomeStore(db);
+// Pass store to createOutcomeService with the host's scope, adapters and resolver.
+// Close db when the host is finished.
+```
+
+Node and Bun use the installed Jaren SQLite drivers. Tests cover independent
+handles, rollback faults, abrupt process exit, reopening, and zero-effect
+completed replay. A driver busy refusal can require an explicit retry after
+contention. Unknown external completion remains uncertain until host
+reconciliation; SQLite does not make remote effects transactional. A reservation
+is audited before external work, and no-dispatch reconciliation fences the old
+worker. Do not combine this receipt store with unrelated nontransactional memory
+and claim atomic projection.
+
+History filtering and pagination execute as indexed scope/sequence SQL queries
+with LIMIT. That bounds returned records; it is not a driver-wide CPU or scan
+budget. The service caps ancestry traversal and detects corrupt immutable bytes.
+Raw database writes remain trusted-host administration, outside supported API
+authority guarantees. See [the outcome kit](../outcomes/docs/ADAPTERS.md) and the
+[measured replay](../../docs/OUTCOME_BENCHMARK.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangleai/store",
-  "version": "0.21.1",
+  "version": "0.25.0",
   "description": "Tangle AI persistence — the MemoryStore contract over SQLite via @jarenjs/db, plus the run/event log the DAG surface reads",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,11 @@
       "types": "./src/ledger-storage.d.ts",
       "import": "./src/ledger-storage.js",
       "default": "./src/ledger-storage.js"
+    },
+    "./outcome-store": {
+      "types": "./src/outcome-store.d.ts",
+      "import": "./src/outcome-store.js",
+      "default": "./src/outcome-store.js"
     }
   },
   "engines": {
@@ -53,14 +58,15 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@tangleai/documents": "^0.21.1",
-    "@tangleai/core": "^0.21.1",
-    "@tangleai/config": "^0.21.1",
-    "@jarenjs/db": "0.84.3",
-    "@jarenjs/validate": "0.84.3",
-    "@tangleai/mas": "^0.21.1",
-    "@jarenjs/core": "0.84.3",
-    "@tangleai/memory": "^0.21.1"
+    "@tangleai/documents": "^0.25.0",
+    "@tangleai/core": "^0.25.0",
+    "@tangleai/config": "^0.25.0",
+    "@jarenjs/db": "0.86.0",
+    "@jarenjs/validate": "0.86.0",
+    "@tangleai/mas": "^0.25.0",
+    "@jarenjs/core": "0.86.0",
+    "@tangleai/memory": "^0.25.0",
+    "@tangleai/outcomes": "^0.25.0"
   },
   "private": false,
   "types": "./src/index.d.ts",

package/src/index.d.ts

@@ -3,6 +3,8 @@ export { TANGLE_DB_MODEL } from './model.ts';
 export { openTangleDb, pickDriver } from './db.ts';
 export type { TangleDb, DbCollection, OpenTangleDbOptions } from './db.ts';
 export { createDbMemoryStore, asRows } from './memory-store.ts';
+export { createOutcomeStore } from './outcome-store.ts';
+export type { OutcomeStoreOptions } from './outcome-store.ts';
 export type { DbMemoryStoreOptions } from './memory-store.ts';
 export { createRunLog } from './runs.ts';
 export type { RunLog, RunRecord, RunEvent, RunLogOptions, RunIdentityStatus, RunView } from './runs.ts';

package/src/index.js

@@ -2,6 +2,7 @@
 export { TANGLE_DB_MODEL } from "./model.js";
 export { openTangleDb, pickDriver } from "./db.js";
 export { createDbMemoryStore, asRows } from "./memory-store.js";
+export { createOutcomeStore } from "./outcome-store.js";
 export { createRunLog } from "./runs.js";
 export { createIdentityRepository } from "./identities.js";
 export { createDocumentStore } from "./document-store.js";

package/src/mas-jobs.js

@@ -102,7 +102,7 @@ export async function ensurePendingMasSegments(db, masStore) {
     for (const run of runs) {
         counts.examined += 1;
         const trace = await masStore.readTrace(run.id);
-        const responded = trace?.interactions.find((interaction) => interaction.status === 'responded' && interaction.resumeSegment !== null);
+        const responded = trace?.interactions.find((interaction) => interaction.status === 'responded' && interaction.resumeSegment === run.segment + 1);
         if (responded === undefined || responded.resumeSegment === null) {
             counts.skipped += 1;
             continue;

package/src/mas-store.d.ts

@@ -8,7 +8,7 @@
  * worker claim epoch (`TMAS2005` for a zombie's stale commit), and node
  * completion as ONE transaction writing the terminal attempt, outbound
  * messages, next state revision, budget snapshot and artifact rows —
- * all or nothing, exactly D6. Every record validates against the
+ * all or nothing. Every record validates against the
  * generated runtime contracts before it is written; persistence never
  * invents a shape. Semantic idempotency: `beginNodeAttempt` returns the
  * stored completion for a key it has already committed and refuses an

package/src/mas-store.js

@@ -8,7 +8,7 @@
  * worker claim epoch (`TMAS2005` for a zombie's stale commit), and node
  * completion as ONE transaction writing the terminal attempt, outbound
  * messages, next state revision, budget snapshot and artifact rows —
- * all or nothing, exactly D6. Every record validates against the
+ * all or nothing. Every record validates against the
  * generated runtime contracts before it is written; persistence never
  * invents a shape. Semantic idempotency: `beginNodeAttempt` returns the
  * stored completion for a key it has already committed and refuses an
@@ -47,6 +47,27 @@ export function createMasStore(db, options = {}) {
             throw error;
         }
     }
+    async function readTraceFrom(reader, runId) {
+        const run = await reader.collection('mas_runs').get(runId);
+        if (run === undefined)
+            return undefined;
+        const view = {
+            run: structuredClone(run),
+            attempts: asRows(await reader.collection('mas_node_attempts').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            messages: asRows(await reader.collection('mas_messages').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            stateRevisions: asRows(await reader.collection('mas_state_revisions').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            interactions: asRows(await reader.collection('mas_interactions').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            artifacts: asRows(await reader.collection('mas_trace_artifacts').execute(matching({ runId }))).map((row) => structuredClone(row)),
+        };
+        return view;
+    }
+    async function enforceTraceLimit(txn, runId) {
+        const trace = await readTraceFrom(txn, runId);
+        const limit = trace?.run.budget.limits?.traceBytes;
+        if (limit !== undefined && new TextEncoder().encode(JSON.stringify(trace)).byteLength > limit) {
+            throw new MasRollback(refuse('TMAS2009', '/limits/traceBytes', 'the retained trace byte budget is spent; the completion was rolled back'));
+        }
+    }
     async function putImmutable(collection, key, value, keyMember) {
         return atomically(async (txn) => {
             const handle = txn.collection(collection);
@@ -221,13 +242,24 @@ export function createMasStore(db, options = {}) {
                 if (!transition.ok)
                     return { ok: false, issue: transition.issue };
                 const next = { ...run, status: transition.status };
+                if (command.settlement) {
+                    const receipt = command.settlement;
+                    if (receipt.claimSeq !== run.claim.seq)
+                        return refuse('TMAS2005', '/claim', 'a stale segment cannot settle the budget');
+                    if (Object.values(receipt.spent).some(n => !Number.isFinite(n) || n < 0))
+                        return refuse('TMAS2009', '/budget/spent', 'invalid budget settlement');
+                    next.budget = { limits: run.budget.limits, spent: { turns: Math.max(run.budget.spent.turns, receipt.spent.turns), tokens: Math.max(run.budget.spent.tokens, receipt.spent.tokens), ms: Math.max(run.budget.spent.ms, receipt.spent.ms) } };
+                }
                 if (command.kind === 'complete')
                     next.output = command.output;
                 if (command.kind === 'fail')
                     next.failure = command.failure;
                 if (command.kind === 'queue-segment')
                     next.segment = run.segment + 1;
-                return writeRun(txn, next);
+                const written = await writeRun(txn, next);
+                if (written.ok && (command.kind === 'complete' || command.kind === 'wait'))
+                    await enforceTraceLimit(txn, runId);
+                return written;
             });
         },
         async putRunFsm(runId, controlId, snapshot) {
@@ -235,7 +267,10 @@ export function createMasStore(db, options = {}) {
                 const run = await readRun(txn, runId);
                 if (run === undefined)
                     return refuse('TMAS2002', '/id', `run '${runId}' does not exist`);
-                return writeRun(txn, { ...run, fsm: { ...run.fsm, [controlId]: snapshot } });
+                const written = await writeRun(txn, { ...run, fsm: { ...run.fsm, [controlId]: snapshot } });
+                if (written.ok)
+                    await enforceTraceLimit(txn, runId);
+                return written;
             });
         },
         async beginNodeAttempt(plan) {
@@ -351,12 +386,13 @@ export function createMasStore(db, options = {}) {
                         spent: {
                             turns: spent.turns + plan.spend.turns,
                             tokens: spent.tokens + plan.spend.tokens,
-                            ms: spent.ms + plan.spend.ms,
+                            ms: Math.max(spent.ms + plan.spend.ms, plan.activeMs ?? 0),
                         },
                     },
                 });
                 if (!written.ok)
                     throw new MasRollback({ ok: false, issue: written.issue });
+                await enforceTraceLimit(txn, plan.runId);
                 return {
                     ok: true,
                     value: {
@@ -382,12 +418,19 @@ export function createMasStore(db, options = {}) {
                 if (current.status !== 'running') {
                     return refuse('TMAS2003', '/status', `only a running attempt can move to '${plan.status}'; '${plan.attemptId}' is '${current.status}'`);
                 }
-                const next = { ...current, status: plan.status, error: plan.error, finishedAt: now() };
+                const next = { ...current, ...plan.receipt, status: plan.status, error: plan.error, finishedAt: now() };
                 const outcome = validateRuntimeRecord('masNodeAttempt', next);
                 if (!outcome.valid) {
                     return refuse('TMAS2004', `/attempt${outcome.issues[0]?.path ?? ''}`, outcome.issues[0]?.detail ?? '');
                 }
                 await handle.put(next);
+                if (plan.receipt !== undefined) {
+                    const charged = plan.receipt.spend, spent = run.budget.spent;
+                    const written = await writeRun(txn, { ...run, budget: { limits: run.budget.limits,
+                            spent: { turns: spent.turns + charged.turns, tokens: spent.tokens + charged.tokens, ms: Math.max(spent.ms + charged.ms, plan.activeMs ?? 0) } } });
+                    if (!written.ok)
+                        throw new MasRollback({ ok: false, issue: written.issue });
+                }
                 return { ok: true, value: structuredClone(next) };
             });
         },
@@ -396,7 +439,7 @@ export function createMasStore(db, options = {}) {
                 const run = await readRun(txn, plan.runId);
                 if (run === undefined)
                     return refuse('TMAS2002', '/id', `run '${plan.runId}' does not exist`);
-                const id = `${plan.runId}:i:${plan.node}`;
+                const id = `${plan.runId}:i:${plan.path}`;
                 const handle = txn.collection('mas_interactions');
                 const existing = await handle.get(id);
                 if (existing !== undefined)
@@ -423,6 +466,7 @@ export function createMasStore(db, options = {}) {
                     return refuse('TMAS2004', `/interaction${outcome.issues[0]?.path ?? ''}`, outcome.issues[0]?.detail ?? '');
                 }
                 await handle.put(interaction);
+                await enforceTraceLimit(txn, plan.runId);
                 return { ok: true, value: structuredClone(interaction) };
             });
         },
@@ -437,6 +481,8 @@ export function createMasStore(db, options = {}) {
                 if (current === undefined)
                     return refuse('TMAS2007', '/id', `interaction '${id}' does not exist`);
                 if (current.status === 'responded' && current.responseKey === responseKey) {
+                    if (!equalsJson(current.response, response))
+                        return refuse('TMAS2007', '/response', 'the response key already identifies different response bytes');
                     return { ok: true, value: structuredClone(current) };
                 }
                 const transition = planInteractionTransition(current.status, 'responded');
@@ -506,19 +552,6 @@ export function createMasStore(db, options = {}) {
             const latest = rows.at(-1);
             return latest === undefined ? undefined : { id: latest.id, value: structuredClone(latest.value) };
         },
-        async readTrace(runId) {
-            const run = await runs().get(runId);
-            if (run === undefined)
-                return undefined;
-            const view = {
-                run: structuredClone(run),
-                attempts: asRows(await attempts().execute(matching({ runId }))).map((row) => structuredClone(row)),
-                messages: asRows(await db.collection('mas_messages').execute(matching({ runId }))).map((row) => structuredClone(row)),
-                stateRevisions: asRows(await db.collection('mas_state_revisions').execute(matching({ runId }))).map((row) => structuredClone(row)),
-                interactions: asRows(await db.collection('mas_interactions').execute(matching({ runId }))).map((row) => structuredClone(row)),
-                artifacts: asRows(await db.collection('mas_trace_artifacts').execute(matching({ runId }))).map((row) => structuredClone(row)),
-            };
-            return view;
-        },
+        async readTrace(runId) { return readTraceFrom(db, runId); },
     };
 }

package/src/model.d.ts

@@ -29,6 +29,89 @@ import type { JsonSchema } from '@tangleai/core/schemas/memory';
 export declare const TANGLE_DB_MODEL: {
     readonly $model: "0.1";
     readonly collections: {
+        readonly outcome_records: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_scope_sequence";
+                readonly path: readonly ["$.scopeId", "$.seq"];
+            }, {
+                readonly name: "by_artifact_kind";
+                readonly path: readonly ["$.scopeId", "$.artifactKey", "$.kind"];
+            }];
+        };
+        readonly outcome_keys: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_scope";
+                readonly path: "$.scopeId";
+            }];
+        };
+        readonly outcome_heads: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_scope";
+                readonly path: "$.scopeId";
+            }];
+        };
+        readonly outcome_operations: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_artifact";
+                readonly path: readonly ["$.scopeId", "$.artifactKey"];
+            }];
+        };
         readonly memories: {
             readonly schema: {
                 readonly type: "object";

package/src/model.js

@@ -29,6 +29,26 @@ const ID = { type: 'string', minLength: 1 };
 export const TANGLE_DB_MODEL = {
     $model: '0.1',
     collections: {
+        outcome_records: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_scope_sequence', path: ['$.scopeId', '$.seq'] }, { name: 'by_artifact_kind', path: ['$.scopeId', '$.artifactKey', '$.kind'] }],
+        },
+        outcome_keys: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_scope', path: '$.scopeId' }],
+        },
+        outcome_heads: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_scope', path: '$.scopeId' }],
+        },
+        outcome_operations: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_artifact', path: ['$.scopeId', '$.artifactKey'] }],
+        },
         memories: {
             schema: { type: 'object', required: ['id'], properties: { id: ID } },
             key: '/id',

package/src/outcome-store.d.ts

@@ -0,0 +1,7 @@
+/** Outcomes use the database's transaction owner, including memory projection. */
+import { type OutcomeStore } from '@tangleai/outcomes';
+import type { TangleDb } from './db.ts';
+export interface OutcomeStoreOptions {
+    applyProbe?: (step: string) => void;
+}
+export declare function createOutcomeStore(db: TangleDb, options?: OutcomeStoreOptions): OutcomeStore;

package/src/outcome-store.js

@@ -0,0 +1,32 @@
+/** Outcomes use the database's transaction owner, including memory projection. */
+import { createOutcomeStoreAdapter } from '@tangleai/outcomes';
+import { asRows } from "./memory-store.js";
+const names = { records: 'outcome_records', keys: 'outcome_keys', heads: 'outcome_heads', operations: 'outcome_operations', memories: 'memories' };
+export function createOutcomeStore(db, options = {}) {
+    const persistence = { transaction: (task) => db.transaction(async (tx) => {
+            const view = {
+                async get(table, id) { return tx.collection(names[table]).get(id); },
+                async put(table, value) { await tx.collection(names[table]).put(value); options.applyProbe?.(`put:${table}`); },
+                async delete(table, id) { await tx.collection(names[table]).delete(id); options.applyProbe?.(`delete:${table}`); },
+                async query(table, q) {
+                    const where = [];
+                    for (const field of ['scopeId', 'artifactKey', 'kind'])
+                        if (q[field] !== undefined)
+                            where.push({ $eq: [`$r.${field}`, { $const: q[field] }] });
+                    if (q.reservedOnly)
+                        where.push({ $eq: ['$r.capacityReserved', true] });
+                    if (q.after !== undefined)
+                        where.push({ $gt: ['$r.seq', q.after] });
+                    if (q.upper !== undefined)
+                        where.push({ $le: ['$r.seq', q.upper] });
+                    const query = { $for: { r: '$[*]' }, ...(where.length ? { $where: { $and: where } } : {}), $orderby: table === 'records' ? ['$r.seq', '$r.id'] : ['$r.id'], $return: '$r' };
+                    const bounded = q.limit === undefined ? query : { $subsequence: [query, 0, q.limit] };
+                    return asRows(await tx.collection(names[table]).execute(bounded));
+                },
+            };
+            const result = await task(view);
+            options.applyProbe?.('commit');
+            return result;
+        }, { mode: 'immediate' }) };
+    return createOutcomeStoreAdapter(persistence);
+}