reqon-dsl 0.3.0 → 0.4.0

package/dist/execution-log/postgres-store.js

@@ -0,0 +1,108 @@
+import { reduceCheckpoints } from './store.js';
+const UNIQUE_VIOLATION = '23505';
+const MAX_APPEND_ATTEMPTS = 8;
+export class PostgresExecutionLog {
+    connectionString;
+    pool;
+    ready;
+    table;
+    constructor(connectionString, options = {}) {
+        this.connectionString = connectionString;
+        this.table = options.table ?? 'reqon_execution_events';
+        // The table name is interpolated into SQL (identifiers can't be bound), so
+        // constrain it to a safe identifier to keep that interpolation injection-free.
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(this.table)) {
+            throw new Error(`Invalid table name: ${this.table}`);
+        }
+    }
+    async ensure() {
+        if (this.pool)
+            return this.pool;
+        if (!this.ready)
+            this.ready = this.init();
+        return this.ready;
+    }
+    async init() {
+        let Pool;
+        try {
+            // Non-literal specifier: keeps the driver an optional dependency with no
+            // compile-time type coupling (no @types/pg required).
+            const specifier = 'pg';
+            const mod = (await import(specifier));
+            const ctor = mod.Pool ?? mod.default?.Pool;
+            if (!ctor)
+                throw new Error('pg.Pool not found');
+            Pool = ctor;
+        }
+        catch {
+            throw new Error("PostgresExecutionLog requires the optional peer dependency 'pg'. " +
+                'Install it with: npm install pg');
+        }
+        const pool = new Pool({ connectionString: this.connectionString });
+        await pool.query(`CREATE TABLE IF NOT EXISTS ${this.table} (
+        execution_id text NOT NULL,
+        seq integer NOT NULL,
+        at text NOT NULL,
+        data jsonb NOT NULL,
+        PRIMARY KEY (execution_id, seq)
+      )`);
+        this.pool = pool;
+        return pool;
+    }
+    async append(event) {
+        const pool = await this.ensure();
+        const at = new Date().toISOString();
+        const data = JSON.stringify(event);
+        for (let attempt = 0; attempt < MAX_APPEND_ATTEMPTS; attempt++) {
+            try {
+                const res = await pool.query(`INSERT INTO ${this.table} (execution_id, seq, at, data)
+           VALUES (
+             $1,
+             (SELECT COALESCE(MAX(seq) + 1, 0) FROM ${this.table} WHERE execution_id = $1),
+             $2,
+             $3::jsonb
+           )
+           RETURNING seq`, [event.executionId, at, data]);
+                return { ...event, seq: res.rows[0].seq, at };
+            }
+            catch (err) {
+                // A concurrent appender claimed this seq first; retry against the new max.
+                if (err.code === UNIQUE_VIOLATION)
+                    continue;
+                throw err;
+            }
+        }
+        throw new Error(`append failed after ${MAX_APPEND_ATTEMPTS} attempts for execution ${event.executionId}`);
+    }
+    async read(executionId) {
+        const pool = await this.ensure();
+        const res = await pool.query(`SELECT seq, at, data FROM ${this.table} WHERE execution_id = $1 ORDER BY seq ASC`, [executionId]);
+        // jsonb comes back already parsed; overlay the assigned seq + recorded time.
+        return res.rows.map((r) => ({ ...r.data, seq: r.seq, at: r.at }));
+    }
+    async listCheckpoints(mission) {
+        const pool = await this.ensure();
+        const res = await pool.query(`SELECT seq, at, data FROM ${this.table} WHERE data->>'type' = 'checkpoint.advanced'`);
+        const events = res.rows.map((r) => ({ ...r.data, seq: r.seq, at: r.at }));
+        return reduceCheckpoints(events, mission);
+    }
+    async listPauses() {
+        const pool = await this.ensure();
+        const res = await pool.query(`SELECT seq, at, data FROM ${this.table}
+       WHERE data->>'type' IN ('pause.created', 'pause.resumed')`);
+        return res.rows.map((r) => ({ ...r.data, seq: r.seq, at: r.at }));
+    }
+    /** Drop all rows. Intended for test setup, not production use. */
+    async reset() {
+        const pool = await this.ensure();
+        await pool.query(`TRUNCATE ${this.table}`);
+    }
+    /** Release the connection pool. */
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = undefined;
+            this.ready = undefined;
+        }
+    }
+}

package/dist/execution-log/resume.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resume helpers: load the current folded state of a run from its log.
+ *
+ * Resume is "read the log, fold it, continue" — never a second execution. A
+ * replaying caller checks {@link FoldedState.appliedEffects} before re-running
+ * a side effect, so an effect recorded before a crash is skipped on resume.
+ */
+import type { ExecutionLogStore } from './store.js';
+import { type FoldedState } from './fold.js';
+/** Read and fold an execution's log into its current state. */
+export declare function loadState(store: ExecutionLogStore, executionId: string): Promise<FoldedState>;

package/dist/execution-log/resume.js

@@ -0,0 +1,5 @@
+import { foldLog } from './fold.js';
+/** Read and fold an execution's log into its current state. */
+export async function loadState(store, executionId) {
+    return foldLog(await store.read(executionId));
+}

package/dist/execution-log/sqlite-store.d.ts

@@ -0,0 +1,16 @@
+import type { ExecutionEvent, StoredEvent } from './events.js';
+import type { CheckpointRecord, ExecutionLogStore } from './store.js';
+export declare class SqliteExecutionLog implements ExecutionLogStore {
+    private path;
+    private db?;
+    private insertStmt?;
+    private readStmt?;
+    private checkpointStmt?;
+    private pauseStmt?;
+    constructor(path?: string);
+    private ensureDb;
+    append(event: ExecutionEvent): Promise<StoredEvent>;
+    read(executionId: string): Promise<StoredEvent[]>;
+    listCheckpoints(mission?: string): Promise<CheckpointRecord[]>;
+    listPauses(): Promise<StoredEvent[]>;
+}

package/dist/execution-log/sqlite-store.js

@@ -0,0 +1,101 @@
+/**
+ * SQLite-backed execution log — durable, transactional state for single-process
+ * self-hosting (the "SQLite-of-durable-execution" lane).
+ *
+ * The `better-sqlite3` driver is an *optional* peer dependency: only installed
+ * by users who opt into the SQLite backend. It is imported lazily so the core
+ * package carries no native dependency, and a missing driver yields a clear,
+ * actionable error rather than an opaque module-resolution failure.
+ *
+ * Durability: WAL mode + `synchronous = NORMAL` gives fsync-backed commits that
+ * survive a process crash, and `seq` is assigned atomically inside the INSERT
+ * (guarded by a `(execution_id, seq)` primary key) so concurrent appenders
+ * cannot collide on a sequence number.
+ */
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { reduceCheckpoints } from './store.js';
+export class SqliteExecutionLog {
+    path;
+    db;
+    insertStmt;
+    readStmt;
+    checkpointStmt;
+    pauseStmt;
+    constructor(path = '.reqon-data/execution-log.sqlite') {
+        this.path = path;
+    }
+    async ensureDb() {
+        if (this.db)
+            return this.db;
+        if (this.path !== ':memory:') {
+            await mkdir(dirname(this.path), { recursive: true });
+        }
+        let Database;
+        try {
+            // Non-literal specifier: keeps the driver an optional dependency with no
+            // compile-time type coupling (no @types/better-sqlite3 required).
+            const specifier = 'better-sqlite3';
+            const mod = (await import(specifier));
+            Database = mod.default;
+        }
+        catch {
+            throw new Error("SqliteExecutionLog requires the optional peer dependency 'better-sqlite3'. " +
+                'Install it with: npm install better-sqlite3');
+        }
+        const db = new Database(this.path);
+        db.pragma('journal_mode = WAL');
+        db.pragma('synchronous = NORMAL');
+        db.exec(`CREATE TABLE IF NOT EXISTS events (
+        execution_id TEXT NOT NULL,
+        seq INTEGER NOT NULL,
+        at TEXT NOT NULL,
+        data TEXT NOT NULL,
+        PRIMARY KEY (execution_id, seq)
+      )`);
+        // seq is computed inside the INSERT so it is assigned atomically, and
+        // RETURNING hands it back without a second round-trip.
+        this.insertStmt = db.prepare(`INSERT INTO events (execution_id, seq, at, data)
+       VALUES (
+         @id,
+         (SELECT COALESCE(MAX(seq) + 1, 0) FROM events WHERE execution_id = @id),
+         @at,
+         @data
+       )
+       RETURNING seq`);
+        this.readStmt = db.prepare(`SELECT seq, at, data FROM events WHERE execution_id = @id ORDER BY seq ASC`);
+        this.checkpointStmt = db.prepare(`SELECT execution_id, seq, at, data FROM events
+       WHERE json_extract(data, '$.type') = 'checkpoint.advanced'`);
+        this.pauseStmt = db.prepare(`SELECT execution_id, seq, at, data FROM events
+       WHERE json_extract(data, '$.type') IN ('pause.created', 'pause.resumed')`);
+        this.db = db;
+        return db;
+    }
+    async append(event) {
+        await this.ensureDb();
+        const at = new Date().toISOString();
+        const { executionId } = event;
+        const row = this.insertStmt.get({
+            id: executionId,
+            at,
+            data: JSON.stringify(event),
+        });
+        return { ...event, seq: row.seq, at };
+    }
+    async read(executionId) {
+        await this.ensureDb();
+        const rows = this.readStmt.all({ id: executionId });
+        return rows.map((r) => ({ ...JSON.parse(r.data), seq: r.seq, at: r.at }));
+    }
+    async listCheckpoints(mission) {
+        await this.ensureDb();
+        const rows = this.checkpointStmt.all({});
+        const events = rows.map((r) => ({ ...JSON.parse(r.data), seq: r.seq, at: r.at }));
+        return reduceCheckpoints(events, mission);
+    }
+    async listPauses() {
+        await this.ensureDb();
+        const rows = this.pauseStmt.all({});
+        return rows.map((r) => ({ ...JSON.parse(r.data), seq: r.seq, at: r.at }));
+    }
+}

package/dist/execution-log/store.d.ts

@@ -0,0 +1,72 @@
+import type { ExecutionEvent, StoredEvent } from './events.js';
+/**
+ * The latest sync checkpoint for a key, materialised across executions — the
+ * read model behind log-backed incremental sync. Derived from the most recent
+ * `checkpoint.advanced` event for each key.
+ */
+export interface CheckpointRecord {
+    key: string;
+    syncedAt: string;
+    recordCount?: number;
+    cursor?: string;
+    mission?: string;
+    /** The execution that advanced this checkpoint. */
+    executionId: string;
+}
+export interface ExecutionLogStore {
+    /** Append one event; returns it with its assigned seq and recorded timestamp. */
+    append(event: ExecutionEvent): Promise<StoredEvent>;
+    /** Read all events for an execution, in append order. */
+    read(executionId: string): Promise<StoredEvent[]>;
+    /**
+     * Latest checkpoint per key across all executions in this store (optionally
+     * filtered by mission). The read model for log-backed incremental sync.
+     */
+    listCheckpoints(mission?: string): Promise<CheckpointRecord[]>;
+    /**
+     * All pause lifecycle events (pause.created / pause.resumed) across every
+     * execution in this store, in no guaranteed order. The raw input the
+     * log-backed pause store folds into pause state.
+     */
+    listPauses(): Promise<StoredEvent[]>;
+}
+/**
+ * Fold `checkpoint.advanced` events into the latest checkpoint per key. "Latest"
+ * is the furthest-advanced sync: ordered by `syncedAt` (so a checkpoint never
+ * moves backwards across runs — incremental sync stays monotonic), ties broken
+ * by the recording time `at` then `seq`. Shared by every store backend so the
+ * read-model semantics stay identical across them.
+ */
+export declare function reduceCheckpoints(events: StoredEvent[], mission?: string): CheckpointRecord[];
+/** In-memory execution log — for tests and ephemeral runs. */
+export declare class MemoryExecutionLog implements ExecutionLogStore {
+    private events;
+    append(event: ExecutionEvent): Promise<StoredEvent>;
+    read(executionId: string): Promise<StoredEvent[]>;
+    listCheckpoints(mission?: string): Promise<CheckpointRecord[]>;
+    listPauses(): Promise<StoredEvent[]>;
+}
+/**
+ * Durable execution log: one append-only JSON-lines file per execution.
+ *
+ * Appends are O_APPEND single-line writes, so a crash mid-write can at worst
+ * leave a torn final line, which {@link read} skips. The log therefore survives
+ * a process restart — a resumed run reads its prior events back. Dev-grade: no
+ * atomic seq assignment or locking. For a transactional single-process backend
+ * use {@link SqliteExecutionLog}; Postgres (multi-node) is still to come.
+ */
+export declare class FileExecutionLog implements ExecutionLogStore {
+    private dir;
+    /** Cached next-seq per execution, lazily initialised from disk. */
+    private counts;
+    constructor(dir?: string);
+    private pathFor;
+    append(event: ExecutionEvent): Promise<StoredEvent>;
+    read(executionId: string): Promise<StoredEvent[]>;
+    listCheckpoints(mission?: string): Promise<CheckpointRecord[]>;
+    listPauses(): Promise<StoredEvent[]>;
+    /** Read and parse every execution's events in this directory. */
+    private readAll;
+    private readRaw;
+    private parse;
+}

package/dist/execution-log/store.js

@@ -0,0 +1,182 @@
+/**
+ * Append-only storage for execution events. The contract: events for a given
+ * execution are read back in append order with a contiguous `seq` starting at 0.
+ */
+import { appendFile, readFile, readdir, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+/** True for the pause lifecycle events the pause read-model folds. */
+function isPauseEvent(event) {
+    return event.type === 'pause.created' || event.type === 'pause.resumed';
+}
+/**
+ * Fold `checkpoint.advanced` events into the latest checkpoint per key. "Latest"
+ * is the furthest-advanced sync: ordered by `syncedAt` (so a checkpoint never
+ * moves backwards across runs — incremental sync stays monotonic), ties broken
+ * by the recording time `at` then `seq`. Shared by every store backend so the
+ * read-model semantics stay identical across them.
+ */
+export function reduceCheckpoints(events, mission) {
+    const latest = new Map();
+    const isNewer = (a, prior) => {
+        if (a.syncedAt !== prior.syncedAt)
+            return a.syncedAt > prior.syncedAt;
+        if (a.at !== prior.at)
+            return a.at > prior.at;
+        return a.seq > prior.seq;
+    };
+    for (const event of events) {
+        if (event.type !== 'checkpoint.advanced')
+            continue;
+        if (mission !== undefined && event.mission !== mission)
+            continue;
+        const candidate = {
+            syncedAt: event.syncedAt,
+            at: event.at,
+            seq: event.seq,
+            record: {
+                key: event.key,
+                syncedAt: event.syncedAt,
+                recordCount: event.recordCount,
+                cursor: event.cursor,
+                mission: event.mission,
+                executionId: event.executionId,
+            },
+        };
+        const prior = latest.get(event.key);
+        if (!prior || isNewer(candidate, prior))
+            latest.set(event.key, candidate);
+    }
+    return Array.from(latest.values()).map((v) => v.record);
+}
+/** In-memory execution log — for tests and ephemeral runs. */
+export class MemoryExecutionLog {
+    events = new Map();
+    async append(event) {
+        const existing = this.events.get(event.executionId);
+        const log = existing ?? [];
+        const stored = { ...event, seq: log.length, at: new Date().toISOString() };
+        log.push(stored);
+        if (!existing)
+            this.events.set(event.executionId, log);
+        return stored;
+    }
+    async read(executionId) {
+        return [...(this.events.get(executionId) ?? [])];
+    }
+    async listCheckpoints(mission) {
+        const all = [];
+        for (const log of this.events.values())
+            all.push(...log);
+        return reduceCheckpoints(all, mission);
+    }
+    async listPauses() {
+        const pauses = [];
+        for (const log of this.events.values())
+            pauses.push(...log.filter(isPauseEvent));
+        return pauses;
+    }
+}
+/**
+ * Durable execution log: one append-only JSON-lines file per execution.
+ *
+ * Appends are O_APPEND single-line writes, so a crash mid-write can at worst
+ * leave a torn final line, which {@link read} skips. The log therefore survives
+ * a process restart — a resumed run reads its prior events back. Dev-grade: no
+ * atomic seq assignment or locking. For a transactional single-process backend
+ * use {@link SqliteExecutionLog}; Postgres (multi-node) is still to come.
+ */
+export class FileExecutionLog {
+    dir;
+    /** Cached next-seq per execution, lazily initialised from disk. */
+    counts = new Map();
+    constructor(dir = '.reqon-data/execution-log') {
+        this.dir = dir;
+    }
+    pathFor(executionId) {
+        // executionId is runtime-generated (uuid); keep the filename simple/safe.
+        const safe = executionId.replace(/[^A-Za-z0-9_.-]/g, '_');
+        return join(this.dir, `${safe}.jsonl`);
+    }
+    async append(event) {
+        await mkdir(this.dir, { recursive: true });
+        let seq = this.counts.get(event.executionId);
+        let prefix = '';
+        if (seq === undefined) {
+            // First append this instance: derive next seq from any persisted events,
+            // and detect an unterminated tail left by a crash mid-append. Writing
+            // straight after it would concatenate this event onto the torn line and
+            // corrupt it; a leading newline terminates the torn line (which read()
+            // still skips) and keeps this event a clean, parseable record.
+            const raw = await this.readRaw(event.executionId);
+            seq = this.parse(raw).length;
+            if (raw.length > 0 && !raw.endsWith('\n'))
+                prefix = '\n';
+        }
+        const stored = { ...event, seq, at: new Date().toISOString() };
+        // The log can carry resume state (e.g. a pause checkpoint's captured
+        // variables), so create files owner-only (0o600) — never world-readable.
+        // mode applies on creation; appends to an existing file keep its mode.
+        await appendFile(this.pathFor(event.executionId), `${prefix}${JSON.stringify(stored)}\n`, {
+            encoding: 'utf-8',
+            mode: 0o600,
+        });
+        this.counts.set(event.executionId, seq + 1);
+        return stored;
+    }
+    async read(executionId) {
+        return this.parse(await this.readRaw(executionId));
+    }
+    async listCheckpoints(mission) {
+        return reduceCheckpoints(await this.readAll(), mission);
+    }
+    async listPauses() {
+        return (await this.readAll()).filter(isPauseEvent);
+    }
+    /** Read and parse every execution's events in this directory. */
+    async readAll() {
+        let files;
+        try {
+            files = await readdir(this.dir);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return [];
+            throw err;
+        }
+        const all = [];
+        for (const file of files) {
+            if (!file.endsWith('.jsonl'))
+                continue;
+            all.push(...this.parse(await readFile(join(this.dir, file), 'utf-8')));
+        }
+        return all;
+    }
+    async readRaw(executionId) {
+        try {
+            return await readFile(this.pathFor(executionId), 'utf-8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return '';
+            throw err;
+        }
+    }
+    parse(content) {
+        const events = [];
+        for (const line of content.split('\n')) {
+            if (line.trim() === '')
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                // A torn line from a crash mid-append. Each event is an independent
+                // single-line record, so skip just this line rather than discarding
+                // everything after it (a healed torn line can sit mid-file, followed
+                // by valid events appended on resume).
+                continue;
+            }
+        }
+        return events;
+    }
+}

package/dist/index.d.ts

@@ -19,8 +19,9 @@ export * from './ast/index.js';
 export { MissionExecutor, HttpClient, BearerAuthProvider, OAuth2AuthProvider, createContext, evaluate, type ExecutionResult, type ExecutionError, type ExecutorConfig, type ExecutionContext, type ProgressCallbacks, type ExecutionStartEvent, type ExecutionCompleteEvent, type StageStartEvent, type StageCompleteEvent, } from './interpreter/index.js';
 export { MemoryStore, FileStore, createStore, type StoreAdapter, type StoreFilter, type StoreConfig, } from './stores/index.js';
 export { createExecutionState, findResumePoint, canResume, getProgress, getExecutionSummary, FileExecutionStore, MemoryExecutionStore, type ExecutionState, type ExecutionStore, type StageState, type LiveProgress, } from './execution/index.js';
+export { MemoryExecutionLog, FileExecutionLog, SqliteExecutionLog, PostgresExecutionLog, foldLog, loadState, effectId, reduceCheckpoints, type ExecutionEvent, type StoredEvent, type ExecutionLogStore, type CheckpointRecord, type FoldedState, } from './execution-log/index.js';
 export { Scheduler, parseCronExpression, getNextRunTime, intervalToMs, shouldRunNow, type ScheduledJob, type SchedulerState, type ScheduleEvent, type SchedulerCallbacks, type SchedulerConfig, type ScheduledMission, } from './scheduler/index.js';
-export { generateCheckpointKey, formatSinceDate, parseSinceDate, EPOCH, FileSyncStore, MemorySyncStore, type SyncCheckpoint, type SyncStore, } from './sync/index.js';
+export { generateCheckpointKey, formatSinceDate, parseSinceDate, EPOCH, FileSyncStore, MemorySyncStore, LogBackedSyncStore, type SyncCheckpoint, type SyncStore, } from './sync/index.js';
 export { ReqonError, ParseError, LexerError, RuntimeError, ValidationError, formatErrors, getSourceLine, getSourceContext, type SourceLocation, type ErrorContext, } from './errors/index.js';
 export { loadMission, isMissionFolder, getMissionName, type LoadResult, type LoadOptions, } from './loader/index.js';
 export { loadEnv, loadCredentials, resolveCredentials, resolveEnvString, hasEnvReference, credentialsFromEnv, type CredentialsConfig, type LoadEnvResult, type AuthCredentials, type SourceCredentials, } from './auth/credentials.js';
@@ -29,8 +30,8 @@ export { ControlServer, type ControlServerConfig, type ControlServerCallbacks, t
 export { ObservabilityEmitter, createEmitter, type ObservabilityEvent, type EventType, type EventHandler, type EventEmitter, type MissionStartPayload, type MissionCompletePayload, type StageStartPayload, type StageCompletePayload, type StepStartPayload, type StepCompletePayload, type FetchStartPayload, type FetchCompletePayload, type DataStorePayload, type LoopStartPayload, type LoopCompletePayload, type WebhookRegisterPayload, type WebhookCompletePayload, createStructuredLogger, ConsoleOutput, JsonLinesOutput, BufferOutput, type StructuredLogger, type LogEntry, type LogOutput, type Span, type CreateLoggerOptions, SpanBuilder, OTelEventAdapter, OTLPExporter, createOTelListener, type OTelSpan, type OTLPExporterConfig, } from './observability/index.js';
 export { MCP_SERVER_VERSION } from './mcp/index.js';
 export { BaseDebugController, CLIDebugger, type DebugController, type DebugMode, type DebugPauseReason, type DebugSnapshot, type DebugCommand, type DebugLocation, } from './debug/index.js';
-export { FileTraceStore, MemoryTraceStore, TraceRecorder, TraceReplayer, createTraceRecorder, createTraceReplayer, createExecutionTrace, safeClone, truncateForTrace, type TraceStore, type TraceSnapshot, type StoreSnapshot as TraceStoreSnapshot, type LoopContext as TraceLoopContext, type ExecutionTrace, type TraceRecorderConfig, type ReplaySession, type ReplayStepResult, type TimelineEvent, type VariableChange, type SnapshotDiff, } from './trace/index.js';
-export { FilePauseStore, MemoryPauseStore, PauseManager, createPauseManager, parseDuration, formatDuration, createPauseState, isPauseExpired, getRemainingTime, getPauseSummary, type PauseStore, type PauseState, type PauseCheckpoint, type PauseResumeTriggerState, type PauseManagerConfig, type CreatePauseOptions, type PauseStatus, } from './pause/index.js';
+export { FileTraceStore, MemoryTraceStore, TraceRecorder, TraceReplayer, LogTraceView, traceTimelineFromLog, createTraceRecorder, createTraceReplayer, createExecutionTrace, safeClone, truncateForTrace, type LogTimelineEntry, type LogTraceSummary, type TraceStore, type TraceSnapshot, type StoreSnapshot as TraceStoreSnapshot, type LoopContext as TraceLoopContext, type ExecutionTrace, type TraceRecorderConfig, type ReplaySession, type ReplayStepResult, type TimelineEvent, type VariableChange, type SnapshotDiff, } from './trace/index.js';
+export { FilePauseStore, MemoryPauseStore, LogBackedPauseStore, PauseManager, createPauseManager, parseDuration, formatDuration, createPauseState, isPauseExpired, getRemainingTime, getPauseSummary, type PauseStore, type PauseState, type PauseCheckpoint, type PauseResumeTriggerState, type PauseManagerConfig, type CreatePauseOptions, type PauseStatus, } from './pause/index.js';
 import { type ExecutorConfig } from './interpreter/index.js';
 import type { ReqonProgram } from './ast/index.js';
 export declare function parse(source: string, filePath?: string): ReqonProgram;

package/dist/index.js

@@ -19,8 +19,9 @@ export * from './ast/index.js';
 export { MissionExecutor, HttpClient, BearerAuthProvider, OAuth2AuthProvider, createContext, evaluate, } from './interpreter/index.js';
 export { MemoryStore, FileStore, createStore, } from './stores/index.js';
 export { createExecutionState, findResumePoint, canResume, getProgress, getExecutionSummary, FileExecutionStore, MemoryExecutionStore, } from './execution/index.js';
+export { MemoryExecutionLog, FileExecutionLog, SqliteExecutionLog, PostgresExecutionLog, foldLog, loadState, effectId, reduceCheckpoints, } from './execution-log/index.js';
 export { Scheduler, parseCronExpression, getNextRunTime, intervalToMs, shouldRunNow, } from './scheduler/index.js';
-export { generateCheckpointKey, formatSinceDate, parseSinceDate, EPOCH, FileSyncStore, MemorySyncStore, } from './sync/index.js';
+export { generateCheckpointKey, formatSinceDate, parseSinceDate, EPOCH, FileSyncStore, MemorySyncStore, LogBackedSyncStore, } from './sync/index.js';
 export { ReqonError, ParseError, LexerError, RuntimeError, ValidationError, formatErrors, getSourceLine, getSourceContext, } from './errors/index.js';
 export { loadMission, isMissionFolder, getMissionName, } from './loader/index.js';
 export { loadEnv, loadCredentials, resolveCredentials, resolveEnvString, hasEnvReference, credentialsFromEnv, } from './auth/credentials.js';
@@ -39,9 +40,9 @@ export { MCP_SERVER_VERSION } from './mcp/index.js';
 // Debug
 export { BaseDebugController, CLIDebugger, } from './debug/index.js';
 // Trace - time-travel debugging
-export { FileTraceStore, MemoryTraceStore, TraceRecorder, TraceReplayer, createTraceRecorder, createTraceReplayer, createExecutionTrace, safeClone, truncateForTrace, } from './trace/index.js';
+export { FileTraceStore, MemoryTraceStore, TraceRecorder, TraceReplayer, LogTraceView, traceTimelineFromLog, createTraceRecorder, createTraceReplayer, createExecutionTrace, safeClone, truncateForTrace, } from './trace/index.js';
 // Pause - resource-free long pauses
-export { FilePauseStore, MemoryPauseStore, PauseManager, createPauseManager, parseDuration, formatDuration, createPauseState, isPauseExpired, getRemainingTime, getPauseSummary, } from './pause/index.js';
+export { FilePauseStore, MemoryPauseStore, LogBackedPauseStore, PauseManager, createPauseManager, parseDuration, formatDuration, createPauseState, isPauseExpired, getRemainingTime, getPauseSummary, } from './pause/index.js';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { ReqonLexer } from './lexer/index.js';

package/dist/interpreter/context.d.ts

@@ -14,6 +14,20 @@
 import type { SchemaDefinition } from 'vague-lang';
 import type { StoreAdapter } from '../stores/types.js';
 import type { HttpClient } from './http.js';
+/**
+ * Mutable per-action execution state. Parallel actions (`run [A, B]`) must not
+ * share this — each gets its own scope so their step counters and deferred sync
+ * checkpoints can't corrupt each other. Nested scopes (for/match) inherit the
+ * same reference so the whole action shares one counter/checkpoint list.
+ */
+export interface ActionScope {
+    /** Monotonic step index within the action (for trace/debug positions). */
+    stepIndex: number;
+    /** Current retry attempt of the action (0-based), for effect identity. */
+    attempt: number;
+    /** Sync checkpoints deferred until the action's data is durably stored. */
+    pendingCheckpoints: Array<() => Promise<void>>;
+}
 export interface ExecutionContext {
     stores: Map<string, StoreAdapter>;
     storeTypes: Map<string, string>;
@@ -22,6 +36,7 @@ export interface ExecutionContext {
     variables: Map<string, unknown>;
     response?: unknown;
     parent?: ExecutionContext;
+    actionScope?: ActionScope;
 }
 export declare function createContext(): ExecutionContext;
 export declare function childContext(parent: ExecutionContext): ExecutionContext;

package/dist/interpreter/context.js

@@ -28,6 +28,9 @@ export function childContext(parent) {
         schemas: parent.schemas,
         variables: new Map(),
         parent,
+        // Nested scopes (for/match) share the action's scope so the step counter
+        // and checkpoint list stay coherent across the whole action.
+        actionScope: parent.actionScope,
     };
 }
 export function getVariable(ctx, name) {