@tangleai/store 0.20.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# @tangleai/store
+
+## 0.20.0
+
+### Minor Changes
+
+- Establish the coordinated 0.20.0 release with JavaScript and TypeScript declaration distributions, preserved public subpaths and JSON schemas, and verified Node and Bun consumers. Use published JarenJS 0.83.3 fixes without a consumer installation patch. Prepare versions before release commits, verify locally, push directly to main and publish CI-verified tarballs. Deploy the website independently from local Tangle workspace source with JarenJS packages from npm, verifying dependency sources and the live commit.
+
+### Patch Changes
+
+- Updated dependencies
+  - @tangleai/core@0.20.0
+  - @tangleai/config@0.20.0
+  - @tangleai/mas@0.20.0
+  - @tangleai/documents@0.20.0
+  - @tangleai/memory@0.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joham (jklarenbeek@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @tangleai/store
+
+Tangle AI persistence — the MemoryStore contract over SQLite via @jarenjs/db, plus the run/event log the DAG surface reads
+
+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.

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@tangleai/store",
+  "version": "0.20.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",
+  "main": "./src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./model": {
+      "types": "./src/model.d.ts",
+      "import": "./src/model.js",
+      "default": "./src/model.js"
+    },
+    "./db": {
+      "types": "./src/db.d.ts",
+      "import": "./src/db.js",
+      "default": "./src/db.js"
+    },
+    "./memory-store": {
+      "types": "./src/memory-store.d.ts",
+      "import": "./src/memory-store.js",
+      "default": "./src/memory-store.js"
+    },
+    "./runs": {
+      "types": "./src/runs.d.ts",
+      "import": "./src/runs.js",
+      "default": "./src/runs.js"
+    },
+    "./package.json": "./package.json",
+    "./mas-store": {
+      "types": "./src/mas-store.d.ts",
+      "import": "./src/mas-store.js",
+      "default": "./src/mas-store.js"
+    },
+    "./mas-jobs": {
+      "types": "./src/mas-jobs.d.ts",
+      "import": "./src/mas-jobs.js",
+      "default": "./src/mas-jobs.js"
+    },
+    "./ledger-storage": {
+      "types": "./src/ledger-storage.d.ts",
+      "import": "./src/ledger-storage.js",
+      "default": "./src/ledger-storage.js"
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@tangleai/documents": "^0.20.0",
+    "@tangleai/core": "^0.20.0",
+    "@tangleai/config": "^0.20.0",
+    "@jarenjs/db": "0.83.3",
+    "@jarenjs/validate": "0.83.3",
+    "@tangleai/mas": "^0.20.0",
+    "@jarenjs/core": "0.83.3",
+    "@tangleai/memory": "^0.20.0"
+  },
+  "private": false,
+  "types": "./src/index.d.ts",
+  "files": [
+    "src/**/*.js",
+    "src/**/*.d.ts",
+    "schemas/**/*.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jklarenbeek/tangleai.git",
+    "directory": "packages/store"
+  }
+}

package/src/db.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Opening the Tangle database — one call, either runtime.
+ *
+ * @jarenjs/db ships BOTH drivers and both import their SQLite binding
+ * lazily inside `open()` (`lazyOpen`), so importing the two modules at
+ * top level is safe everywhere: under Node the `bun:` specifier is never
+ * resolved, under Bun `node:sqlite` is never resolved. The pick is one
+ * runtime probe: `process.versions.bun`.
+ *
+ * The handles are @jarenjs/db's own published types — `Store` from
+ * `openStore`, `Collection<T>` from `store.collection<T>(name)` with the
+ * document shape stated where the handle is taken — so nothing about
+ * the store's surface is restated here; the two aliases only keep
+ * Tangle's names.
+ */
+import { type Collection, type OpenStoreOptions, type Store } from '@jarenjs/db';
+/** A @jarenjs/db collection handle over documents of shape `T`. */
+export type DbCollection<T = unknown> = Collection<T>;
+/** The @jarenjs/db store handle. */
+export type TangleDb = Store;
+/** The suite's host options, including transaction policy, runtime, native
+ * pragmas, validation, live bounds and read-only profiles. */
+export interface OpenTangleDbOptions extends Omit<OpenStoreOptions, 'driver'> {
+    driver?: OpenStoreOptions['driver'];
+}
+export declare function pickDriver(): OpenStoreOptions['driver'];
+export declare function openTangleDb(options?: OpenTangleDbOptions): Promise<TangleDb>;

package/src/db.js

@@ -0,0 +1,28 @@
+/**
+ * Opening the Tangle database — one call, either runtime.
+ *
+ * @jarenjs/db ships BOTH drivers and both import their SQLite binding
+ * lazily inside `open()` (`lazyOpen`), so importing the two modules at
+ * top level is safe everywhere: under Node the `bun:` specifier is never
+ * resolved, under Bun `node:sqlite` is never resolved. The pick is one
+ * runtime probe: `process.versions.bun`.
+ *
+ * The handles are @jarenjs/db's own published types — `Store` from
+ * `openStore`, `Collection<T>` from `store.collection<T>(name)` with the
+ * document shape stated where the handle is taken — so nothing about
+ * the store's surface is restated here; the two aliases only keep
+ * Tangle's names.
+ */
+import { openStore } from '@jarenjs/db';
+import { nodeDriver } from '@jarenjs/db/node';
+import { bunDriver } from '@jarenjs/db/bun';
+import { TANGLE_DB_MODEL } from "./model.js";
+export function pickDriver() {
+    return typeof process !== 'undefined' && process.versions?.bun !== undefined
+        ? bunDriver()
+        : nodeDriver();
+}
+export function openTangleDb(options = {}) {
+    const driver = options.driver ?? pickDriver();
+    return openStore(TANGLE_DB_MODEL, { ...options, driver, path: options.path ?? ':memory:' });
+}

package/src/document-store.d.ts

@@ -0,0 +1,3 @@
+import { type DocumentCorpusStore } from '@tangleai/documents/contracts';
+import type { TangleDb } from './db.ts';
+export declare function createDocumentStore(db: TangleDb): DocumentCorpusStore;

package/src/document-store.js

@@ -0,0 +1,124 @@
+import { assertDocumentChunk, assertDocumentElement, assertDocumentSource, assertDocumentVersion, } from '@tangleai/documents/contracts';
+import { asRows } from "./memory-store.js";
+async function rows(db, collection, fields = {}) {
+    return asRows(await db.collection(collection).execute({
+        $for: { row: '$[*]' },
+        $where: Object.keys(fields).length === 0 ? true : { $and: Object.entries(fields).map(([field, value]) => ({ $eq: [`$row.${field}`, { $const: value }] })) },
+        $return: '$row',
+    }));
+}
+export function createDocumentStore(db) {
+    const sources = db.collection('sources');
+    const versions = db.collection('document_versions');
+    const elements = db.collection('document_elements');
+    const chunks = db.collection('document_chunks');
+    const locks = new Map();
+    async function serial(sourceId, operation) {
+        while (locks.has(sourceId))
+            await locks.get(sourceId);
+        let release = () => { };
+        const held = new Promise((resolve) => { release = resolve; });
+        locks.set(sourceId, held);
+        try {
+            return await operation();
+        }
+        finally {
+            locks.delete(sourceId);
+            release();
+        }
+    }
+    async function cleanupVersion(scope, versionId) {
+        const scopedElements = scope.collection('document_elements');
+        const scopedChunks = scope.collection('document_chunks');
+        const oldElements = await rows(scope, 'document_elements', { versionId });
+        const oldChunks = await rows(scope, 'document_chunks', { versionId });
+        for (const chunk of oldChunks)
+            await scopedChunks.delete(chunk.id);
+        for (const element of oldElements)
+            await scopedElements.delete(element.id);
+    }
+    return {
+        getSource: (id) => sources.get(id),
+        async listSources() {
+            const result = await rows(db, 'sources');
+            result.sort((a, b) => b.fetchedAt.localeCompare(a.fetchedAt));
+            return result;
+        },
+        getVersion: (id) => versions.get(id),
+        async listVersions(sourceId) {
+            const result = await rows(db, 'document_versions', sourceId === undefined ? {} : { sourceId });
+            return result
+                .sort((a, b) => b.fetchedAt.localeCompare(a.fetchedAt));
+        },
+        async listElements(versionId) {
+            return (await rows(db, 'document_elements', { versionId }))
+                .sort((a, b) => a.order - b.order);
+        },
+        async listChunks(versionId) {
+            return (await rows(db, 'document_chunks', versionId === undefined ? {} : { versionId }))
+                .sort((a, b) => a.sourceId.localeCompare(b.sourceId) || a.order - b.order);
+        },
+        async putSource(source) {
+            assertDocumentSource(source);
+            await sources.put(source);
+        },
+        async activate(bundle) {
+            await serial(bundle.source.id, async () => {
+                assertDocumentSource(bundle.source);
+                assertDocumentVersion(bundle.version);
+                for (const element of bundle.elements)
+                    assertDocumentElement(element);
+                for (const chunk of bundle.chunks)
+                    assertDocumentChunk(chunk);
+                if (bundle.source.activeVersionId !== bundle.version.id)
+                    throw new Error('Source activeVersionId must name the staged version');
+                if (bundle.version.sourceId !== bundle.source.id
+                    || bundle.elements.some((item) => item.sourceId !== bundle.source.id || item.versionId !== bundle.version.id)
+                    || bundle.chunks.some((item) => item.sourceId !== bundle.source.id || item.versionId !== bundle.version.id)) {
+                    throw new Error('Document bundle identifiers do not agree');
+                }
+                const staging = { ...bundle.version, status: 'staging', activatedAt: undefined, error: undefined };
+                await db.transaction(async (transaction) => {
+                    const scopedSources = transaction.collection('sources');
+                    const scopedVersions = transaction.collection('document_versions');
+                    const scopedElements = transaction.collection('document_elements');
+                    const scopedChunks = transaction.collection('document_chunks');
+                    const previous = await scopedSources.get(bundle.source.id);
+                    await scopedVersions.put(staging);
+                    for (const element of bundle.elements)
+                        await scopedElements.put(element);
+                    for (const chunk of bundle.chunks)
+                        await scopedChunks.put(chunk);
+                    const active = { ...staging, status: 'active', activatedAt: bundle.source.fetchedAt };
+                    await scopedVersions.put(active);
+                    await scopedSources.put({ ...bundle.source, status: 'ready', error: undefined });
+                    const previousId = previous?.activeVersionId;
+                    if (previousId !== undefined && previousId !== bundle.version.id) {
+                        const previousVersion = await scopedVersions.get(previousId);
+                        if (previousVersion !== undefined) {
+                            await scopedVersions.put({ ...previousVersion, status: 'superseded', supersededAt: bundle.source.fetchedAt });
+                        }
+                        await cleanupVersion(transaction, previousId);
+                    }
+                });
+            });
+        },
+        async recordFailure(source, version) {
+            await serial(source.id, async () => {
+                assertDocumentSource(source);
+                const current = await sources.get(source.id);
+                const activeVersionId = current?.activeVersionId ?? source.activeVersionId;
+                const retained = activeVersionId === undefined
+                    ? source
+                    : { ...(current ?? source), activeVersionId, status: 'ready', error: source.error, fetchedAt: source.fetchedAt };
+                await sources.put(retained);
+                if (version !== undefined) {
+                    assertDocumentVersion(version);
+                    const known = await versions.get(version.id);
+                    if (known?.status !== 'active')
+                        await versions.put({ ...version, status: 'failed' });
+                }
+            });
+        },
+    };
+}

package/src/identities.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The identity repository — content-addressed, credential-free run
+ * identities, stored once and referenced by id from runs and chats.
+ *
+ * A stored identity is immutable by construction: its id is the
+ * canonical SHA-256 of its own payload, recomputed HERE before every
+ * write, so a caller cannot store a mutated identity under a stale id
+ * or repeat mutable settings snapshots into the log. Validation is the
+ * config package's — the same schema every report envelope uses — and a
+ * document that does not validate or does not hash to its claimed id is
+ * refused as a value.
+ */
+import { type Issue, type RunIdentity } from '@tangleai/config';
+import type { TangleDb } from './db.ts';
+export interface IdentityRepository {
+    /** Validate, verify the content address, and store (idempotent). */
+    put(identity: RunIdentity): Promise<{
+        ok: true;
+        id: string;
+    } | {
+        ok: false;
+        issues: Issue[];
+    }>;
+    get(id: string): Promise<RunIdentity | undefined>;
+    list(): Promise<RunIdentity[]>;
+}
+export declare function createIdentityRepository(db: TangleDb): IdentityRepository;

package/src/identities.js

@@ -0,0 +1,43 @@
+/**
+ * The identity repository — content-addressed, credential-free run
+ * identities, stored once and referenced by id from runs and chats.
+ *
+ * A stored identity is immutable by construction: its id is the
+ * canonical SHA-256 of its own payload, recomputed HERE before every
+ * write, so a caller cannot store a mutated identity under a stale id
+ * or repeat mutable settings snapshots into the log. Validation is the
+ * config package's — the same schema every report envelope uses — and a
+ * document that does not validate or does not hash to its claimed id is
+ * refused as a value.
+ */
+import { identityIdOf, validateRunIdentity } from '@tangleai/config';
+import { asRows } from "./memory-store.js";
+export function createIdentityRepository(db) {
+    const collection = db.collection('config_identities');
+    return {
+        async put(identity) {
+            const outcome = validateRunIdentity(identity);
+            if (!outcome.ok)
+                return outcome;
+            const { identityId, ...body } = outcome.value;
+            const recomputed = await identityIdOf(body);
+            if (recomputed !== identityId) {
+                return {
+                    ok: false,
+                    issues: [{ code: 'TCFG1007', path: '/identityId', detail: 'the identity does not hash to its claimed id; a mutated identity cannot be stored under a stale address' }],
+                };
+            }
+            await collection.put({ id: identityId, value: outcome.value });
+            return { ok: true, id: identityId };
+        },
+        async get(id) {
+            const row = await collection.get(id);
+            return row?.value;
+        },
+        async list() {
+            const rows = asRows(await collection.execute({ $for: { r: '$[*]' }, $return: '$r' }));
+            rows.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+            return rows.map((row) => row.value);
+        },
+    };
+}

package/src/index.d.ts

@@ -0,0 +1,16 @@
+/** @tangleai/store barrel. */
+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 type { DbMemoryStoreOptions } from './memory-store.ts';
+export { createRunLog } from './runs.ts';
+export type { RunLog, RunRecord, RunEvent, RunLogOptions, RunIdentityStatus, RunView } from './runs.ts';
+export { createIdentityRepository } from './identities.ts';
+export type { IdentityRepository } from './identities.ts';
+export { createDocumentStore } from './document-store.ts';
+export { createMasStore } from './mas-store.ts';
+export { createDbLedgerStorage } from './ledger-storage.ts';
+export type { MasStoreOptions } from './mas-store.ts';
+export { enqueueMasSegment, ensurePendingMasSegments, createMasSegmentWorker, createMasSegmentHandlers, namespacedRegionCheckpoints, MasSegmentRefusal, } from './mas-jobs.ts';
+export type { MasSegmentPayload, EnqueueMasSegmentPlan, MasSegmentContext, MasSegmentExecutor, MasWorkerOptions, MasWorker, RegionCheckpointStore, } from './mas-jobs.ts';

package/src/index.js

@@ -0,0 +1,10 @@
+/** @tangleai/store barrel. */
+export { TANGLE_DB_MODEL } from "./model.js";
+export { openTangleDb, pickDriver } from "./db.js";
+export { createDbMemoryStore, asRows } from "./memory-store.js";
+export { createRunLog } from "./runs.js";
+export { createIdentityRepository } from "./identities.js";
+export { createDocumentStore } from "./document-store.js";
+export { createMasStore } from "./mas-store.js";
+export { createDbLedgerStorage } from "./ledger-storage.js";
+export { enqueueMasSegment, ensurePendingMasSegments, createMasSegmentWorker, createMasSegmentHandlers, namespacedRegionCheckpoints, MasSegmentRefusal, } from "./mas-jobs.js";

package/src/ledger-storage.d.ts

@@ -0,0 +1,3 @@
+import type { MasLedgerStorage } from '@tangleai/mas';
+import type { TangleDb } from './db.ts';
+export declare function createDbLedgerStorage(db: TangleDb, namespace: string): MasLedgerStorage;

package/src/ledger-storage.js

@@ -0,0 +1,46 @@
+/** Atomic AI ledger storage over the existing key/value collection. The suite
+ * owns ledger staging, conflict retries and retention; this adapter publishes
+ * each synchronous mutation through the database's transaction owner. */
+import { cloneJson, equalsJson } from '@jarenjs/core/object';
+import { asRows } from "./memory-store.js";
+export function createDbLedgerStorage(db, namespace) {
+    if (typeof namespace !== 'string' || namespace.length === 0)
+        throw new TypeError('ledger storage needs a namespace');
+    const prefix = `ai-ledger/${JSON.stringify(namespace)}/`;
+    const slots = db.collection('settings');
+    const query = (part) => ({
+        $for: { s: '$[*]' }, $where: { '$starts-with': ['$s.key', part] },
+        $orderby: ['$s.key'], $return: '$s',
+    });
+    return {
+        get: async (key) => (await slots.get(prefix + key))?.value,
+        set: async (key, value) => { await slots.put({ key: prefix + key, value: cloneJson(value) }); },
+        delete: async (key) => { await slots.delete(prefix + key); },
+        keys: async (part = '') => asRows(await slots.execute(query(prefix + part))).map((slot) => slot.key.slice(prefix.length)),
+        mutate: async (scope, transform) => db.transaction(async (tx) => {
+            const handle = tx.collection('settings');
+            const prefixes = typeof scope === 'string' ? [scope] : scope.prefixes ?? [];
+            const keys = typeof scope === 'string' ? [] : scope.keys ?? [];
+            const matches = (key) => keys.includes(key) || prefixes.some((part) => key.startsWith(part));
+            const rows = asRows(await handle.execute(query(prefix))).filter((slot) => matches(slot.key.slice(prefix.length)));
+            const current = Object.fromEntries(rows.map((slot) => [slot.key.slice(prefix.length), slot.value]));
+            const outcome = transform(cloneJson(current));
+            if (!outcome || typeof outcome.then === 'function')
+                throw new TypeError('ledger mutations must be synchronous');
+            if (outcome.next !== undefined) {
+                const next = cloneJson(outcome.next);
+                if (next === null || typeof next !== 'object' || Array.isArray(next) || Object.keys(next).some((key) => !matches(key))) {
+                    throw new TypeError('ledger mutation escaped its scope');
+                }
+                for (const key of Object.keys(current))
+                    if (!Object.hasOwn(next, key))
+                        await handle.delete(prefix + key);
+                for (const [key, value] of Object.entries(next)) {
+                    if (!Object.hasOwn(current, key) || !equalsJson(current[key], value))
+                        await handle.put({ key: prefix + key, value });
+                }
+            }
+            return outcome.result;
+        }, { mode: 'immediate' }),
+    };
+}

package/src/mas-jobs.d.ts

@@ -0,0 +1,121 @@
+/**
+ * MAS durable segments over the suite queue — composition, not a queue.
+ *
+ * Enqueue is the suite's own idempotent caller-supplied-id enqueue with
+ * the derived segment id `<masRunId>:<segment>` and the versioned kind
+ * `mas:<executableRevision>`; re-enqueueing one segment is the suite's
+ * no-op, and an unknown versioned kind is simply never claimed by a
+ * worker that does not register it. The worker is
+ * `store.jobs.createWorker`; the checkpoint store every region hands
+ * `compileDag` is a thin NAMESPACE adaptation over the suite's
+ * `context.checkpoints` — load filters by
+ * `<region>/<branch>/<iteration>/`, save prefixes the lowered node id
+ * and delegates (keeping the suite's lease guard and JSON validation),
+ * a region result is a prefixed delegated save, and only a terminal
+ * outcome for the whole runnable segment calls the suite store's
+ * `complete`, which atomically records the segment result, marks the
+ * job done and prunes that segment's checkpoint rows. It grows no map,
+ * table or serialization of its own.
+ *
+ * Before any checkpoint loads, the handler reads the MAS run and
+ * refuses `TMAS2002` unless the job id, payload, workflow version,
+ * registry snapshot and executable revision all agree — Jaren DAG
+ * resume under different document bytes is undefined, so a mismatch
+ * never reaches a checkpoint.
+ */
+import { type MasIssue, type MasRun, type MasStore } from '@tangleai/mas';
+import type { TangleDb } from './db.ts';
+import type { JobWorker, JobWorkerOptions } from '@jarenjs/db';
+export interface MasSegmentPayload {
+    runId: string;
+    segment: number;
+    workflowVersionId: string;
+    registryRevision: string;
+    executableRevision: string;
+    /** The typed resume event for a post-interaction segment, or null for segment 0. */
+    resume: unknown;
+}
+export interface EnqueueMasSegmentPlan {
+    runId: string;
+    segment: number;
+    workflowVersionId: string;
+    registryRevision: string;
+    executableRevision: string;
+    resume?: unknown;
+}
+/** Idempotent per segment: the suite keeps one row per caller-supplied id. */
+export declare function enqueueMasSegment(db: TangleDb, plan: EnqueueMasSegmentPlan): Promise<string>;
+/** The suite checkpoint store contract compileDag consumes. */
+export interface RegionCheckpointStore {
+    load(runId: string): unknown;
+    save(runId: string, nodeId: string, value: unknown): unknown;
+    complete(runId: string, result: unknown): unknown;
+}
+interface SuiteCheckpoints {
+    load(runId: string): unknown;
+    save(runId: string, nodeId: string, value: unknown): unknown;
+    complete(runId: string, result: unknown): unknown;
+}
+/**
+ * The namespace adaptation: one region incarnation's view of the
+ * segment's suite checkpoint rows. Region-level `complete` records a
+ * prefixed result via delegated save and deliberately does NOT mark the
+ * job done.
+ */
+export declare function namespacedRegionCheckpoints(suite: SuiteCheckpoints, segmentJobId: string, namespace: string): RegionCheckpointStore;
+export interface MasSegmentContext {
+    run: MasRun;
+    payload: MasSegmentPayload;
+    segmentJobId: string;
+    claimSeq: number;
+    signal: AbortSignal;
+    /** One region incarnation's namespaced checkpoint view. */
+    checkpointsFor(namespace: string): RegionCheckpointStore;
+    /**
+     * The segment's terminal outcome: atomically records the result, marks
+     * the suite job done and prunes this segment's checkpoint rows. Called
+     * exactly once per runnable segment — whole-run completion/failure or a
+     * durable interaction wait.
+     */
+    completeSegment(result: unknown): Promise<void>;
+}
+export type MasSegmentExecutor = (context: MasSegmentContext) => Promise<void>;
+export interface MasWorkerOptions extends Omit<JobWorkerOptions, 'handlers'> {
+    /** The executable revisions this worker can run — its registered kinds. */
+    executableRevisions: string[];
+    execute: MasSegmentExecutor;
+}
+export type MasWorker = JobWorker;
+/** A refusal the queue records as the job's failure value. */
+export declare class MasSegmentRefusal extends Error {
+    issue: MasIssue;
+    constructor(issue: MasIssue);
+}
+/**
+ * The semantic resume reconciler over the published queue — not another
+ * queue. `respondInteraction` accepts exactly one typed response and
+ * moves the run to `resume_pending` with a reserved zero-padded segment
+ * id; the enqueue of that derived id happens OUTSIDE the semantic
+ * transaction (the suite queue cannot be assumed to join it), so this
+ * scan makes the seam idempotent: it enqueues every reserved segment
+ * (the suite's caller-supplied-id no-op absorbs a crash after enqueue)
+ * and CAS-advances `resume_pending -> queued`. The second identical
+ * reconciliation changes zero rows and reports zero; every enqueue,
+ * skip and conflict is a counted value.
+ */
+export declare function ensurePendingMasSegments(db: TangleDb, masStore: MasStore): Promise<{
+    examined: number;
+    enqueued: number;
+    queued: number;
+    skipped: number;
+}>;
+export type MasHandlerContext = Pick<Parameters<JobWorkerOptions['handlers'][string]>[1], 'job' | 'checkpoints' | 'signal'>;
+export type MasSegmentHandlers = Record<string, (payload: unknown, context: MasHandlerContext) => Promise<unknown>>;
+/**
+ * The versioned segment handlers a worker registers — exported so the
+ * crash matrix can drive one claim at a time deterministically through
+ * `store.jobs.claim` with an injected clock, without a polling loop.
+ */
+export declare function createMasSegmentHandlers(masStore: MasStore, options: Pick<MasWorkerOptions, 'executableRevisions' | 'execute' | 'owner'>): MasSegmentHandlers;
+export declare function createMasSegmentWorker(db: TangleDb, masStore: MasStore, options: MasWorkerOptions): MasWorker;
+export {};