reqon-dsl 0.2.0 → 0.4.0

package/dist/parser/pipeline-parser.d.ts

@@ -0,0 +1,12 @@
+import type { PipelineDefinition, PipelineStage } from '../ast/nodes.js';
+import { ActionParser } from './action-parser.js';
+export declare class PipelineParser extends ActionParser {
+    /**
+     * Parse a pipeline definition: run ActionA then ActionB then [ActionC, ActionD]
+     */
+    parsePipeline(): PipelineDefinition;
+    /**
+     * Parse a single pipeline stage (can be single action or parallel actions)
+     */
+    protected parsePipelineStage(): PipelineStage;
+}

package/dist/parser/pipeline-parser.js

@@ -0,0 +1,52 @@
+/**
+ * Pipeline parsing
+ * Handles parsing of pipeline definitions and stages.
+ */
+import { TokenType } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { ActionParser } from './action-parser.js';
+export class PipelineParser extends ActionParser {
+    /**
+     * Parse a pipeline definition: run ActionA then ActionB then [ActionC, ActionD]
+     */
+    parsePipeline() {
+        this.consume(ReqonTokenType.RUN, "Expected 'run'");
+        const stages = [];
+        // First stage
+        stages.push(this.parsePipelineStage());
+        // Subsequent stages with 'then'
+        while (this.match(TokenType.THEN)) {
+            stages.push(this.parsePipelineStage());
+        }
+        return { type: 'PipelineDefinition', stages };
+    }
+    /**
+     * Parse a single pipeline stage (can be single action or parallel actions)
+     */
+    parsePipelineStage() {
+        let condition;
+        // Check for parallel stage: [Action1, Action2, ...]
+        if (this.match(TokenType.LBRACKET)) {
+            const actions = [];
+            // First action
+            actions.push(this.consume(TokenType.IDENTIFIER, 'Expected action name').value);
+            // Additional actions separated by commas
+            while (this.match(TokenType.COMMA)) {
+                actions.push(this.consume(TokenType.IDENTIFIER, 'Expected action name').value);
+            }
+            this.consume(TokenType.RBRACKET, "Expected ']'");
+            // Optional 'if' condition
+            if (this.match(TokenType.IF)) {
+                condition = this.parseExpression();
+            }
+            return { actions, condition };
+        }
+        // Single action (sequential)
+        const action = this.consume(TokenType.IDENTIFIER, 'Expected action name').value;
+        // Optional 'if' condition
+        if (this.match(TokenType.IF)) {
+            condition = this.parseExpression();
+        }
+        return { action, condition };
+    }
+}

package/dist/parser/schedule-parser.d.ts

@@ -0,0 +1,7 @@
+import type { ScheduleDefinition, IntervalSchedule, ScheduleRetryConfig } from '../ast/nodes.js';
+import { SourceParser } from './source-parser.js';
+export declare class ScheduleParser extends SourceParser {
+    parseSchedule(): ScheduleDefinition;
+    protected parseIntervalSchedule(): IntervalSchedule;
+    protected parseScheduleRetryConfig(): ScheduleRetryConfig;
+}

package/dist/parser/schedule-parser.js

@@ -0,0 +1,137 @@
+/**
+ * Schedule definition parsing
+ * Handles parsing of schedule definitions (interval, cron, and one-time schedules).
+ */
+import { TokenType } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { SourceParser } from './source-parser.js';
+export class ScheduleParser extends SourceParser {
+    parseSchedule() {
+        this.consume(ReqonTokenType.SCHEDULE, "Expected 'schedule'");
+        this.consume(TokenType.COLON, "Expected ':'");
+        let scheduleType;
+        let interval;
+        let cronExpression;
+        let runAt;
+        let timezone;
+        let maxConcurrency;
+        let skipIfRunning;
+        let retryOnFailure;
+        // Determine schedule type
+        if (this.check(ReqonTokenType.EVERY)) {
+            // Interval-based: schedule: every 6 hours
+            scheduleType = 'interval';
+            interval = this.parseIntervalSchedule();
+        }
+        else if (this.check(ReqonTokenType.CRON)) {
+            // Cron-based: schedule: cron "0 */6 * * *"
+            scheduleType = 'cron';
+            this.advance(); // consume 'cron'
+            cronExpression = this.consume(TokenType.STRING, 'Expected cron expression string').value;
+        }
+        else if (this.check(ReqonTokenType.AT)) {
+            // One-time: schedule: at "2025-01-20 09:00 UTC"
+            scheduleType = 'once';
+            this.advance(); // consume 'at'
+            runAt = this.consume(TokenType.STRING, 'Expected datetime string').value;
+        }
+        else {
+            throw this.error(`Expected 'every', 'cron', or 'at' for schedule type`);
+        }
+        // Optional configuration block
+        if (this.match(TokenType.LBRACE)) {
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                // Handle keyword tokens that can appear as option keys
+                let key;
+                if (this.check(ReqonTokenType.RETRY)) {
+                    this.advance();
+                    key = 'retry';
+                }
+                else {
+                    key = this.consume(TokenType.IDENTIFIER, 'Expected schedule option key').value;
+                }
+                this.consume(TokenType.COLON, "Expected ':'");
+                switch (key) {
+                    case 'timezone':
+                        timezone = this.consume(TokenType.STRING, 'Expected timezone string').value;
+                        break;
+                    case 'maxConcurrency':
+                        maxConcurrency = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                        break;
+                    case 'skipIfRunning':
+                        skipIfRunning = this.match(TokenType.TRUE);
+                        if (!skipIfRunning) {
+                            this.consume(TokenType.FALSE, "Expected 'true' or 'false'");
+                        }
+                        break;
+                    case 'retry':
+                        retryOnFailure = this.parseScheduleRetryConfig();
+                        break;
+                    default:
+                        throw this.error(`Unknown schedule option: ${key}`);
+                }
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+        }
+        return {
+            type: 'ScheduleDefinition',
+            scheduleType,
+            interval,
+            cronExpression,
+            runAt,
+            timezone,
+            maxConcurrency,
+            skipIfRunning,
+            retryOnFailure,
+        };
+    }
+    parseIntervalSchedule() {
+        this.consume(ReqonTokenType.EVERY, "Expected 'every'");
+        const value = parseInt(this.consume(TokenType.NUMBER, 'Expected interval value').value, 10);
+        let unit;
+        const unitToken = this.advance();
+        switch (unitToken.type) {
+            case ReqonTokenType.SECONDS:
+                unit = 'seconds';
+                break;
+            case ReqonTokenType.MINUTES:
+                unit = 'minutes';
+                break;
+            case ReqonTokenType.HOURS:
+                unit = 'hours';
+                break;
+            case ReqonTokenType.DAYS:
+                unit = 'days';
+                break;
+            case ReqonTokenType.WEEKS:
+                unit = 'weeks';
+                break;
+            default:
+                throw this.error(`Expected time unit (seconds, minutes, hours, days, weeks), got: ${unitToken.value}`);
+        }
+        return { value, unit };
+    }
+    parseScheduleRetryConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        let maxRetries = 3;
+        let delaySeconds = 60;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected retry option').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'maxRetries':
+                    maxRetries = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'delaySeconds':
+                    delaySeconds = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                default:
+                    throw this.error(`Unknown retry option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { maxRetries, delaySeconds };
+    }
+}

package/dist/parser/source-parser.d.ts

@@ -0,0 +1,9 @@
+import type { SourceDefinition, SourceConfig, AuthConfig, RateLimitSourceConfig, CircuitBreakerSourceConfig } from '../ast/nodes.js';
+import { ReqonExpressionParser } from './expressions.js';
+export declare class SourceParser extends ReqonExpressionParser {
+    parseSource(): SourceDefinition;
+    protected parseSourceConfig(hasOAS?: boolean): SourceConfig;
+    protected parseRateLimitConfig(): RateLimitSourceConfig;
+    protected parseCircuitBreakerConfig(): CircuitBreakerSourceConfig;
+    protected parseAuthConfig(): AuthConfig;
+}

package/dist/parser/source-parser.js

@@ -0,0 +1,151 @@
+/**
+ * Source definition parsing
+ * Handles parsing of source definitions, auth config, rate limiting, and circuit breaker config.
+ */
+import { TokenType } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { ReqonExpressionParser } from './expressions.js';
+export class SourceParser extends ReqonExpressionParser {
+    parseSource() {
+        this.consume(ReqonTokenType.SOURCE, "Expected 'source'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected source name').value;
+        // Check for 'from' clause (OAS spec path)
+        let specPath;
+        if (this.match(ReqonTokenType.FROM)) {
+            specPath = this.consume(TokenType.STRING, 'Expected OAS spec path').value;
+        }
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const config = this.parseSourceConfig(specPath !== undefined);
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'SourceDefinition', name, specPath, config };
+    }
+    parseSourceConfig(hasOAS = false) {
+        let auth;
+        let base;
+        let validateResponses;
+        let rateLimit;
+        let circuitBreaker;
+        const headers = {};
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected config key').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            if (key === 'auth') {
+                auth = this.parseAuthConfig();
+            }
+            else if (key === 'base') {
+                base = this.consume(TokenType.STRING, 'Expected base URL string').value;
+            }
+            else if (key === 'validateResponses') {
+                validateResponses = this.match(TokenType.TRUE);
+                if (!validateResponses) {
+                    this.consume(TokenType.FALSE, "Expected 'true' or 'false'");
+                }
+            }
+            else if (key === 'headers') {
+                this.consume(TokenType.LBRACE, "Expected '{'");
+                while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                    const headerName = this.consume(TokenType.STRING, 'Expected header name').value;
+                    this.consume(TokenType.COLON, "Expected ':'");
+                    headers[headerName] = this.parseExpression();
+                    this.match(TokenType.COMMA);
+                }
+                this.consume(TokenType.RBRACE, "Expected '}'");
+            }
+            else if (key === 'rateLimit') {
+                rateLimit = this.parseRateLimitConfig();
+            }
+            else if (key === 'circuitBreaker') {
+                circuitBreaker = this.parseCircuitBreakerConfig();
+            }
+            this.match(TokenType.COMMA);
+        }
+        if (!auth)
+            throw this.error('Source must have auth config');
+        // Base URL is only required if not using OAS
+        if (!base && !hasOAS)
+            throw this.error('Source must have base URL (or use OAS spec)');
+        return {
+            auth,
+            base,
+            validateResponses,
+            headers: Object.keys(headers).length > 0 ? headers : undefined,
+            rateLimit,
+            circuitBreaker,
+        };
+    }
+    parseRateLimitConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const config = {};
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected rate limit option').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'strategy':
+                    config.strategy = this.consume(TokenType.IDENTIFIER, 'Expected strategy').value;
+                    break;
+                case 'maxWait':
+                    config.maxWait = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'fallbackRpm':
+                    config.fallbackRpm = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                default:
+                    throw this.error(`Unknown rate limit option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return config;
+    }
+    parseCircuitBreakerConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const config = {};
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected circuit breaker option').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'failureThreshold':
+                    config.failureThreshold = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'resetTimeout':
+                    config.resetTimeout = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'successThreshold':
+                    config.successThreshold = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'failureWindow':
+                    config.failureWindow = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                default:
+                    throw this.error(`Unknown circuit breaker option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return config;
+    }
+    parseAuthConfig() {
+        const typeToken = this.advance();
+        let type;
+        switch (typeToken.type) {
+            case ReqonTokenType.OAUTH2:
+                type = 'oauth2';
+                break;
+            case ReqonTokenType.BEARER:
+                type = 'bearer';
+                break;
+            case ReqonTokenType.BASIC:
+                type = 'basic';
+                break;
+            case ReqonTokenType.API_KEY:
+                type = 'api_key';
+                break;
+            case ReqonTokenType.NONE:
+                type = 'none';
+                break;
+            default:
+                throw this.error(`Unknown auth type: ${typeToken.value}`);
+        }
+        return { type };
+    }
+}

package/dist/pause/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pause Module - Resource-free long pauses for Reqon
+ *
+ * Provides pause functionality that persists state and releases resources:
+ * - PauseManager: Creates and manages pauses
+ * - PauseStore: Persists pause state
+ * - Resume triggers: timeout, webhook, manual
+ */
+export type { PauseState, PauseResumeTriggerState, PauseCheckpoint } from './state.js';
+export { generatePauseId, parseDuration, formatDuration, createPauseState, isPauseExpired, getRemainingTime, getPauseSummary, } from './state.js';
+export type { PauseStore } from './store.js';
+export { FilePauseStore, MemoryPauseStore } from './store.js';
+export { LogBackedPauseStore } from './log-store.js';
+export type { PauseManagerConfig, CreatePauseOptions, PauseStatus } from './manager.js';
+export { PauseManager, createPauseManager } from './manager.js';

package/dist/pause/index.js

@@ -0,0 +1,12 @@
+/**
+ * Pause Module - Resource-free long pauses for Reqon
+ *
+ * Provides pause functionality that persists state and releases resources:
+ * - PauseManager: Creates and manages pauses
+ * - PauseStore: Persists pause state
+ * - Resume triggers: timeout, webhook, manual
+ */
+export { generatePauseId, parseDuration, formatDuration, createPauseState, isPauseExpired, getRemainingTime, getPauseSummary, } from './state.js';
+export { FilePauseStore, MemoryPauseStore } from './store.js';
+export { LogBackedPauseStore } from './log-store.js';
+export { PauseManager, createPauseManager } from './manager.js';

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

@@ -0,0 +1,33 @@
+/**
+ * Log-backed pause store: resource-free long pauses as a view over the
+ * execution log.
+ *
+ * In durable mode the execution log holds the full pause record — a
+ * `pause.created` event carries the pause state (deadline, resume triggers,
+ * captured checkpoint), and `pause.resumed` records how and when it ended. A
+ * paused run, and the timer or webhook it waits on, are therefore reconstructable
+ * from the log alone, with no separate pause file. This adapter folds those
+ * events back into {@link PauseState}.
+ */
+import type { ExecutionLogStore } from '../execution-log/index.js';
+import type { PauseStore } from './store.js';
+import type { PauseState } from './state.js';
+export declare class LogBackedPauseStore implements PauseStore {
+    private log;
+    constructor(log: ExecutionLogStore);
+    save(pause: PauseState): Promise<void>;
+    update(id: string, updates: Partial<PauseState>): Promise<void>;
+    load(id: string): Promise<PauseState | null>;
+    loadByExecution(executionId: string): Promise<PauseState | null>;
+    listActive(): Promise<PauseState[]>;
+    listByMission(mission: string): Promise<PauseState[]>;
+    findExpired(): Promise<PauseState[]>;
+    /** Append-only: deletion is a no-op (history is retained in the log). */
+    delete(): Promise<void>;
+    private allPauses;
+    /**
+     * Fold pause events into the latest state per pause id. A `pause.created`
+     * seeds the state; later `pause.resumed` events apply the terminal status.
+     */
+    private foldPauses;
+}

package/dist/pause/log-store.js

@@ -0,0 +1,98 @@
+/** Coerce a value that may be a Date or an ISO string back to a Date. */
+function toDate(value) {
+    return value instanceof Date ? value : new Date(value);
+}
+function restoreDates(pause) {
+    pause.pausedAt = toDate(pause.pausedAt);
+    pause.expiresAt = toDate(pause.expiresAt);
+    if (pause.resumedAt)
+        pause.resumedAt = toDate(pause.resumedAt);
+    return pause;
+}
+export class LogBackedPauseStore {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    async save(pause) {
+        await this.log.append({
+            executionId: pause.executionId,
+            type: 'pause.created',
+            pauseId: pause.id,
+            pause,
+        });
+    }
+    async update(id, updates) {
+        const pause = await this.load(id);
+        if (!pause)
+            throw new Error(`Pause not found: ${id}`);
+        const resumedBy = updates.resumedBy ?? 'manual';
+        await this.log.append({
+            executionId: pause.executionId,
+            type: 'pause.resumed',
+            pauseId: id,
+            resumedBy,
+            status: updates.status ?? 'resumed',
+            resumedAt: (updates.resumedAt ?? new Date()).toISOString(),
+            webhookPayload: updates.webhookPayload,
+        });
+    }
+    async load(id) {
+        const byId = this.foldPauses(await this.log.listPauses());
+        return byId.get(id) ?? null;
+    }
+    async loadByExecution(executionId) {
+        const all = this.foldPauses(await this.log.listPauses());
+        for (const pause of all.values()) {
+            if (pause.executionId === executionId && pause.status === 'waiting')
+                return pause;
+        }
+        return null;
+    }
+    async listActive() {
+        return (await this.allPauses())
+            .filter((p) => p.status === 'waiting')
+            .sort((a, b) => a.expiresAt.getTime() - b.expiresAt.getTime());
+    }
+    async listByMission(mission) {
+        return (await this.allPauses())
+            .filter((p) => p.mission === mission)
+            .sort((a, b) => b.pausedAt.getTime() - a.pausedAt.getTime());
+    }
+    async findExpired() {
+        const now = new Date();
+        return (await this.listActive()).filter((p) => p.expiresAt <= now);
+    }
+    /** Append-only: deletion is a no-op (history is retained in the log). */
+    async delete() { }
+    async allPauses() {
+        return Array.from(this.foldPauses(await this.log.listPauses()).values());
+    }
+    /**
+     * Fold pause events into the latest state per pause id. A `pause.created`
+     * seeds the state; later `pause.resumed` events apply the terminal status.
+     */
+    foldPauses(events) {
+        const byId = new Map();
+        for (const event of events) {
+            if (event.type === 'pause.created' && event.pause) {
+                byId.set(event.pauseId, restoreDates({ ...event.pause }));
+            }
+        }
+        // Apply resumptions after every create is loaded (events aren't ordered).
+        for (const event of events) {
+            if (event.type !== 'pause.resumed')
+                continue;
+            const pause = byId.get(event.pauseId);
+            if (!pause)
+                continue;
+            pause.status = event.status ?? 'resumed';
+            pause.resumedBy = event.resumedBy;
+            if (event.resumedAt)
+                pause.resumedAt = new Date(event.resumedAt);
+            if (event.webhookPayload !== undefined)
+                pause.webhookPayload = event.webhookPayload;
+        }
+        return byId;
+    }
+}

package/dist/pause/manager.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Pause Manager - Orchestrates resource-free long pauses
+ *
+ * Handles pause creation, monitoring, and resume coordination.
+ * Integrates with webhook server for webhook-based resume triggers.
+ */
+import type { PauseStore } from './store.js';
+import type { WebhookServer } from '../webhook/index.js';
+import { type PauseState, type PauseCheckpoint } from './state.js';
+export interface PauseManagerConfig {
+    /** Store for persisting pause states */
+    store: PauseStore;
+    /** Webhook server for webhook-based resume (optional) */
+    webhookServer?: WebhookServer;
+    /** Polling interval for checking expired pauses (ms) */
+    pollInterval?: number;
+    /** Callback when a pause is resumed */
+    onResume?: (pause: PauseState) => void | Promise<void>;
+    /** Logger function */
+    log?: (message: string) => void;
+}
+/**
+ * Options for creating a pause
+ */
+export interface CreatePauseOptions {
+    /** Execution ID */
+    executionId: string;
+    /** Mission name */
+    mission: string;
+    /** Duration (e.g., "7d", "12h", or milliseconds) */
+    duration: string | number;
+    /** Checkpoint data for resuming */
+    checkpoint: PauseCheckpoint;
+    /** Resume triggers */
+    resumeTriggers?: Array<{
+        type: 'timeout';
+    } | {
+        type: 'webhook';
+        path: string;
+    }>;
+}
+/**
+ * Manages resource-free long pauses
+ */
+export declare class PauseManager {
+    private config;
+    private pollTimer?;
+    private isRunning;
+    private resuming;
+    private isCheckingExpired;
+    constructor(config: PauseManagerConfig);
+    /**
+     * Create a new pause and persist state
+     */
+    createPause(options: CreatePauseOptions): Promise<PauseState>;
+    /**
+     * Resume a pause manually
+     */
+    resumeManually(pauseId: string): Promise<PauseState>;
+    /**
+     * Resume a pause by execution ID
+     */
+    resumeByExecution(executionId: string): Promise<PauseState | null>;
+    /**
+     * Cancel a pause (without resuming execution)
+     */
+    cancelPause(pauseId: string): Promise<void>;
+    /**
+     * Handle webhook callback for a pause
+     */
+    handleWebhook(pauseId: string, payload: unknown): Promise<boolean>;
+    /**
+     * Start monitoring for expired pauses
+     */
+    startMonitoring(): void;
+    /**
+     * Stop monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Check for and process expired pauses
+     */
+    checkExpiredPauses(): Promise<PauseState[]>;
+    /**
+     * Get all active pauses
+     */
+    getActivePauses(): Promise<PauseState[]>;
+    /**
+     * Get pause by ID
+     */
+    getPause(pauseId: string): Promise<PauseState | null>;
+    /**
+     * Get pause status summary
+     */
+    getStatus(): Promise<PauseStatus>;
+    /**
+     * Transition a pause to `resumed` and fire `onResume` exactly once.
+     *
+     * Returns the resumed pause, or `null` if this call lost the race (another
+     * resume already claimed it, or it is no longer waiting). The claim on
+     * `this.resuming` is synchronous — taken before any `await` — so two
+     * concurrent callers (e.g. the timeout poller and an inbound webhook) can't
+     * both pass the status check and double-fire the side-effecting tail. The
+     * persisted-status re-check makes resume idempotent across poll cycles too.
+     */
+    private markResumed;
+    private registerWebhookTrigger;
+    private cleanupWebhooks;
+    private log;
+}
+/**
+ * Pause status summary
+ */
+export interface PauseStatus {
+    totalActive: number;
+    waiting: number;
+    expired: number;
+    nextExpiration?: Date;
+    pauses: Array<{
+        id: string;
+        mission: string;
+        executionId: string;
+        remaining: number;
+        remainingFormatted: string;
+    }>;
+}
+/**
+ * Create a pause manager
+ */
+export declare function createPauseManager(config: PauseManagerConfig): PauseManager;