@reactive-skills/runtime 0.1.0

package/dist/core/fsm-engine.d.ts

@@ -0,0 +1,94 @@
+import { SkillManifest, StateDefinition, SignalEvent, PromptSlice, EventContext, ChildRunSummary, DecisionRecord } from './types.js';
+import { EventStore } from './event-store.js';
+export interface FSMEngineOptions {
+    skillDir: string;
+    workspaceDir?: string;
+    eventStore?: EventStore;
+    eventContext?: EventContext;
+    runId?: string;
+    initialContext?: Record<string, any>;
+    autoRehydrate?: boolean;
+}
+export declare class FSMEngine {
+    private skillDir;
+    private workspaceDir;
+    private manifest;
+    private activeStatePath;
+    private context;
+    private eventStore;
+    private projectionEngine;
+    private signalQueue;
+    private isProcessingQueue;
+    private signalQueueDepth;
+    private turnsSinceLastSignal;
+    private inBypassState;
+    private readonly strictExecution;
+    constructor(options: FSMEngineOptions);
+    /**
+     * Rehydrate state machine state and context from immutable event history,
+     * resuming from the latest point-in-time state snapshot if available (PERF-02 / INV-08)
+     */
+    private rehydrate;
+    private loadManifest;
+    getManifest(): SkillManifest;
+    getCurrentState(): string;
+    getActiveStatePath(): string[];
+    getContext(): Record<string, any>;
+    updateContext(updates: Record<string, any>): void;
+    getEventStore(): EventStore;
+    getEventContext(): EventContext;
+    isStrictExecution(): boolean;
+    getTurnsSinceLastSignal(): number;
+    isBypassDetected(): boolean;
+    recordTurnStart(): void;
+    checkBypass(): void;
+    recordChildRunStarted(childSkillId: string, childRunId: string, requestId?: string): SignalEvent;
+    recordChildRunCompleted(summary: ChildRunSummary): SignalEvent;
+    invokeSkill(skillNameOrPath: string): Promise<{
+        skillId: string;
+        currentState: string;
+        promptSlice: PromptSlice;
+        event: SignalEvent;
+    }>;
+    recordDecision(decision: DecisionRecord, source?: string): SignalEvent;
+    /**
+     * Resolves full hierarchical path including default/initial substates
+     */
+    private resolveInitialPath;
+    /**
+     * Get StateDefinition by path hierarchy
+     */
+    getStateDefinition(pathSegments: string[]): StateDefinition | null;
+    /**
+     * Generates the prompt slice for the active state hierarchy
+     */
+    generatePromptSlice(): PromptSlice;
+    /**
+     * Check if current state has a blocking Human-in-the-Loop gate
+     */
+    isWaitingForHuman(): boolean;
+    /**
+     * Process an incoming signal event, evaluating transitions with HSM bubbling and draining queued signals
+     */
+    handleSignal(signalName: string, payload?: Record<string, any>, metadata?: {
+        source?: string;
+        causationId?: string;
+    }): Promise<{
+        transitioned: boolean;
+        previousState: string;
+        newState: string;
+        event: SignalEvent;
+        handledAtDepth?: number;
+        deliverablesWritten: string[];
+    }>;
+    /**
+     * Transition between two hierarchical paths executing exit, transition, and entry hooks
+     */
+    private transitionBetweenPaths;
+    /**
+     * Enter a state hierarchy starting below the common ancestor
+     */
+    private enterPath;
+    private executeEntryHook;
+    private executeExitHook;
+}