@fractary/faber 1.2.1 → 2.1.0

package/dist/state/manager.js

@@ -1,48 +1,12 @@
-"use strict";
 /**
  * @fractary/faber - State Manager
  *
  * Workflow state persistence and recovery.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateManager = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const config_1 = require("../config");
-const errors_1 = require("../errors");
+import * as fs from 'fs';
+import * as path from 'path';
+import { loadStateConfig, findProjectRoot } from '../config';
+import { StateError } from '../errors';
 /**
  * Generate a unique workflow ID
  */
@@ -81,14 +45,64 @@ function defaultPhaseState() {
  *
  * Handles workflow state persistence, checkpoints, and recovery.
  */
-class StateManager {
+export class StateManager {
     config;
     stateDir;
     constructor(config) {
-        this.config = config || (0, config_1.loadStateConfig)();
-        const projectRoot = (0, config_1.findProjectRoot)();
+        this.config = config || loadStateConfig();
+        const projectRoot = findProjectRoot();
         this.stateDir = this.config.localPath || path.join(projectRoot, '.faber', 'state');
     }
+    // =========================================================================
+    // Noun-First Grouped API (New)
+    // =========================================================================
+    /**
+     * Workflow operations
+     */
+    workflow = {
+        create: (workId) => this._createWorkflow(workId),
+        save: (state) => this._saveWorkflow(state),
+        get: (workflowId) => this._getWorkflow(workflowId),
+        getActive: (workId) => this._getActiveWorkflow(workId),
+        list: (options) => this._listWorkflows(options),
+        delete: (workflowId) => this._deleteWorkflow(workflowId),
+        pause: (workflowId) => this._pauseWorkflow(workflowId),
+        resume: (workflowId) => this._resumeWorkflow(workflowId),
+        recover: (workflowId, options) => this._recoverWorkflow(workflowId, options),
+    };
+    /**
+     * Phase operations
+     */
+    phase = {
+        update: (workflowId, phase, updates, options) => this._updatePhase(workflowId, phase, updates, options),
+        start: (workflowId, phase) => this._startPhase(workflowId, phase),
+        complete: (workflowId, phase, outputs) => this._completePhase(workflowId, phase, outputs),
+        fail: (workflowId, phase, error) => this._failPhase(workflowId, phase, error),
+        skip: (workflowId, phase, reason) => this._skipPhase(workflowId, phase, reason),
+    };
+    /**
+     * Checkpoint operations
+     */
+    checkpoint = {
+        create: (workflowId, phase, step, data) => this._createCheckpoint(workflowId, phase, step, data),
+        get: (checkpointId) => this._getCheckpoint(checkpointId),
+        list: (workflowId) => this._listCheckpoints(workflowId),
+        getLatest: (workflowId) => this._getLatestCheckpoint(workflowId),
+    };
+    /**
+     * Manifest operations
+     */
+    manifest = {
+        create: (workflowId, workId) => this._createManifest(workflowId, workId),
+        save: (manifest) => this._saveManifest(manifest),
+        get: (manifestId) => this._getManifest(manifestId),
+        addPhase: (manifestId, phaseManifest) => this._addPhaseToManifest(manifestId, phaseManifest),
+        addArtifact: (manifestId, artifact) => this._addArtifactToManifest(manifestId, artifact),
+        complete: (manifestId, status) => this._completeManifest(manifestId, status),
+    };
+    // =========================================================================
+    // Private Implementation Methods
+    // =========================================================================
     /**
      * Ensure state directory exists
      */
@@ -106,12 +120,12 @@ class StateManager {
         return path.join(this.ensureStateDir(type), `${id}.json`);
     }
     // =========================================================================
-    // Workflow State Operations
+    // Workflow State Operations (Private)
     // =========================================================================
     /**
      * Create a new workflow state
      */
-    createWorkflow(workId) {
+    _createWorkflow(workId) {
         const workflowId = generateWorkflowId();
         const now = new Date().toISOString();
         const state = {
@@ -129,13 +143,13 @@ class StateManager {
             updated_at: now,
             status: 'running',
         };
-        this.saveWorkflow(state);
+        this._saveWorkflow(state);
         return state;
     }
     /**
      * Save workflow state
      */
-    saveWorkflow(state) {
+    _saveWorkflow(state) {
         const filePath = this.getStatePath('workflows', state.workflow_id);
         state.updated_at = new Date().toISOString();
         fs.writeFileSync(filePath, JSON.stringify(state, null, 2), 'utf-8');
@@ -146,7 +160,7 @@ class StateManager {
     /**
      * Get workflow state by ID
      */
-    getWorkflow(workflowId) {
+    _getWorkflow(workflowId) {
         const filePath = this.getStatePath('workflows', workflowId);
         if (!fs.existsSync(filePath)) {
             return null;
@@ -156,18 +170,18 @@ class StateManager {
     /**
      * Get active workflow for a work item
      */
-    getActiveWorkflow(workId) {
+    _getActiveWorkflow(workId) {
         const activeFile = this.getStatePath('active', workId);
         if (!fs.existsSync(activeFile)) {
             return null;
         }
         const active = JSON.parse(fs.readFileSync(activeFile, 'utf-8'));
-        return this.getWorkflow(active.workflow_id);
+        return this._getWorkflow(active.workflow_id);
     }
     /**
      * List all workflows
      */
-    listWorkflows(options) {
+    _listWorkflows(options) {
         const workflowsDir = this.ensureStateDir('workflows');
         const files = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.json'));
         const workflows = [];
@@ -193,14 +207,14 @@ class StateManager {
     /**
      * Update workflow phase
      */
-    updatePhase(workflowId, phase, updates, options) {
-        const state = this.getWorkflow(workflowId);
+    _updatePhase(workflowId, phase, updates, options) {
+        const state = this._getWorkflow(workflowId);
         if (!state) {
-            throw new errors_1.StateError(`Workflow not found: ${workflowId}`);
+            throw new StateError(`Workflow not found: ${workflowId}`);
         }
         // Create checkpoint if requested
         if (options?.createCheckpoint) {
-            this.createCheckpoint(workflowId, phase, 'phase_update', { updates });
+            this._createCheckpoint(workflowId, phase, 'phase_update', { updates });
         }
         // Update phase state
         const currentPhaseState = state.phase_states[phase];
@@ -223,24 +237,24 @@ class StateManager {
         else if (phase === 'release' && updates.status === 'completed') {
             state.status = 'completed';
         }
-        this.saveWorkflow(state);
+        this._saveWorkflow(state);
         return state;
     }
     /**
      * Start a phase
      */
-    startPhase(workflowId, phase) {
-        return this.updatePhase(workflowId, phase, {
+    _startPhase(workflowId, phase) {
+        return this._updatePhase(workflowId, phase, {
             status: 'in_progress',
             started_at: new Date().toISOString(),
-            attempts: (this.getWorkflow(workflowId)?.phase_states[phase].attempts || 0) + 1,
+            attempts: (this._getWorkflow(workflowId)?.phase_states[phase].attempts || 0) + 1,
         });
     }
     /**
      * Complete a phase
      */
-    completePhase(workflowId, phase, outputs) {
-        return this.updatePhase(workflowId, phase, {
+    _completePhase(workflowId, phase, outputs) {
+        return this._updatePhase(workflowId, phase, {
             status: 'completed',
             completed_at: new Date().toISOString(),
             outputs,
@@ -249,8 +263,8 @@ class StateManager {
     /**
      * Fail a phase
      */
-    failPhase(workflowId, phase, error) {
-        return this.updatePhase(workflowId, phase, {
+    _failPhase(workflowId, phase, error) {
+        return this._updatePhase(workflowId, phase, {
             status: 'failed',
             error,
         });
@@ -258,8 +272,8 @@ class StateManager {
     /**
      * Skip a phase
      */
-    skipPhase(workflowId, phase, reason) {
-        return this.updatePhase(workflowId, phase, {
+    _skipPhase(workflowId, phase, reason) {
+        return this._updatePhase(workflowId, phase, {
             status: 'skipped',
             error: reason,
         });
@@ -267,39 +281,39 @@ class StateManager {
     /**
      * Pause workflow
      */
-    pauseWorkflow(workflowId) {
-        const state = this.getWorkflow(workflowId);
+    _pauseWorkflow(workflowId) {
+        const state = this._getWorkflow(workflowId);
         if (!state) {
-            throw new errors_1.StateError(`Workflow not found: ${workflowId}`);
+            throw new StateError(`Workflow not found: ${workflowId}`);
         }
         state.status = 'paused';
-        this.saveWorkflow(state);
+        this._saveWorkflow(state);
         // Create checkpoint for recovery
-        this.createCheckpoint(workflowId, state.current_phase, 'pause', {});
+        this._createCheckpoint(workflowId, state.current_phase, 'pause', {});
         return state;
     }
     /**
      * Resume workflow
      */
-    resumeWorkflow(workflowId) {
-        const state = this.getWorkflow(workflowId);
+    _resumeWorkflow(workflowId) {
+        const state = this._getWorkflow(workflowId);
         if (!state) {
-            throw new errors_1.StateError(`Workflow not found: ${workflowId}`);
+            throw new StateError(`Workflow not found: ${workflowId}`);
         }
         if (state.status !== 'paused') {
-            throw new errors_1.StateError(`Workflow is not paused: ${workflowId}`);
+            throw new StateError(`Workflow is not paused: ${workflowId}`);
         }
         state.status = 'running';
-        this.saveWorkflow(state);
+        this._saveWorkflow(state);
         return state;
     }
     // =========================================================================
-    // Checkpoint Operations
+    // Checkpoint Operations (Private)
     // =========================================================================
     /**
      * Create a checkpoint
      */
-    createCheckpoint(workflowId, phase, step, data) {
+    _createCheckpoint(workflowId, phase, step, data) {
         const checkpoint = {
             id: generateCheckpointId(),
             workflow_id: workflowId,
@@ -315,7 +329,7 @@ class StateManager {
     /**
      * Get checkpoint by ID
      */
-    getCheckpoint(checkpointId) {
+    _getCheckpoint(checkpointId) {
         const filePath = this.getStatePath('checkpoints', checkpointId);
         if (!fs.existsSync(filePath)) {
             return null;
@@ -325,7 +339,7 @@ class StateManager {
     /**
      * List checkpoints for a workflow
      */
-    listCheckpoints(workflowId) {
+    _listCheckpoints(workflowId) {
         const checkpointsDir = this.ensureStateDir('checkpoints');
         const files = fs.readdirSync(checkpointsDir).filter(f => f.endsWith('.json'));
         const checkpoints = [];
@@ -342,17 +356,17 @@ class StateManager {
     /**
      * Get latest checkpoint for a workflow
      */
-    getLatestCheckpoint(workflowId) {
-        const checkpoints = this.listCheckpoints(workflowId);
+    _getLatestCheckpoint(workflowId) {
+        const checkpoints = this._listCheckpoints(workflowId);
         return checkpoints.length > 0 ? checkpoints[checkpoints.length - 1] : null;
     }
     // =========================================================================
-    // Run Manifest Operations
+    // Run Manifest Operations (Private)
     // =========================================================================
     /**
      * Create a run manifest
      */
-    createManifest(workflowId, workId) {
+    _createManifest(workflowId, workId) {
         const manifest = {
             manifest_id: generateManifestId(),
             workflow_id: workflowId,
@@ -362,20 +376,20 @@ class StateManager {
             phases: [],
             artifacts: [],
         };
-        this.saveManifest(manifest);
+        this._saveManifest(manifest);
         return manifest;
     }
     /**
      * Save run manifest
      */
-    saveManifest(manifest) {
+    _saveManifest(manifest) {
         const filePath = this.getStatePath('manifests', manifest.manifest_id);
         fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2), 'utf-8');
     }
     /**
      * Get run manifest
      */
-    getManifest(manifestId) {
+    _getManifest(manifestId) {
         const filePath = this.getStatePath('manifests', manifestId);
         if (!fs.existsSync(filePath)) {
             return null;
@@ -385,54 +399,54 @@ class StateManager {
     /**
      * Add phase to manifest
      */
-    addPhaseToManifest(manifestId, phaseManifest) {
-        const manifest = this.getManifest(manifestId);
+    _addPhaseToManifest(manifestId, phaseManifest) {
+        const manifest = this._getManifest(manifestId);
         if (!manifest) {
-            throw new errors_1.StateError(`Manifest not found: ${manifestId}`);
+            throw new StateError(`Manifest not found: ${manifestId}`);
         }
         manifest.phases.push(phaseManifest);
-        this.saveManifest(manifest);
+        this._saveManifest(manifest);
     }
     /**
      * Add artifact to manifest
      */
-    addArtifactToManifest(manifestId, artifact) {
-        const manifest = this.getManifest(manifestId);
+    _addArtifactToManifest(manifestId, artifact) {
+        const manifest = this._getManifest(manifestId);
         if (!manifest) {
-            throw new errors_1.StateError(`Manifest not found: ${manifestId}`);
+            throw new StateError(`Manifest not found: ${manifestId}`);
         }
         manifest.artifacts.push(artifact);
-        this.saveManifest(manifest);
+        this._saveManifest(manifest);
     }
     /**
      * Complete manifest
      */
-    completeManifest(manifestId, status) {
-        const manifest = this.getManifest(manifestId);
+    _completeManifest(manifestId, status) {
+        const manifest = this._getManifest(manifestId);
         if (!manifest) {
-            throw new errors_1.StateError(`Manifest not found: ${manifestId}`);
+            throw new StateError(`Manifest not found: ${manifestId}`);
         }
         manifest.completed_at = new Date().toISOString();
         manifest.status = status;
-        this.saveManifest(manifest);
+        this._saveManifest(manifest);
         return manifest;
     }
     // =========================================================================
-    // Recovery Operations
+    // Recovery Operations (Private)
     // =========================================================================
     /**
      * Recover a workflow from a checkpoint or phase
      */
-    recoverWorkflow(workflowId, options) {
-        const state = this.getWorkflow(workflowId);
+    _recoverWorkflow(workflowId, options) {
+        const state = this._getWorkflow(workflowId);
         if (!state) {
-            throw new errors_1.StateError(`Workflow not found: ${workflowId}`);
+            throw new StateError(`Workflow not found: ${workflowId}`);
         }
         // If recovering from a specific checkpoint
         if (options?.checkpointId) {
-            const checkpoint = this.getCheckpoint(options.checkpointId);
+            const checkpoint = this._getCheckpoint(options.checkpointId);
             if (!checkpoint) {
-                throw new errors_1.StateError(`Checkpoint not found: ${options.checkpointId}`);
+                throw new StateError(`Checkpoint not found: ${options.checkpointId}`);
             }
             state.current_phase = checkpoint.phase;
         }
@@ -441,7 +455,7 @@ class StateManager {
             const phases = ['frame', 'architect', 'build', 'evaluate', 'release'];
             const fromIndex = phases.indexOf(options.fromPhase);
             if (fromIndex === -1) {
-                throw new errors_1.StateError(`Invalid phase: ${options.fromPhase}`);
+                throw new StateError(`Invalid phase: ${options.fromPhase}`);
             }
             state.current_phase = options.fromPhase;
             // Reset phases from the recovery point
@@ -458,22 +472,22 @@ class StateManager {
             }
         }
         state.status = 'running';
-        this.saveWorkflow(state);
+        this._saveWorkflow(state);
         return state;
     }
     // =========================================================================
-    // Cleanup Operations
+    // Cleanup Operations (Private)
     // =========================================================================
     /**
      * Delete workflow state
      */
-    deleteWorkflow(workflowId) {
+    _deleteWorkflow(workflowId) {
         const workflowPath = this.getStatePath('workflows', workflowId);
         if (!fs.existsSync(workflowPath)) {
             return false;
         }
         // Get the work_id to clean up active state
-        const state = this.getWorkflow(workflowId);
+        const state = this._getWorkflow(workflowId);
         if (state) {
             const activePath = this.getStatePath('active', state.work_id);
             if (fs.existsSync(activePath)) {
@@ -483,6 +497,9 @@ class StateManager {
         fs.unlinkSync(workflowPath);
         return true;
     }
+    // =========================================================================
+    // Public Utility Methods
+    // =========================================================================
     /**
      * Clean up old workflows and checkpoints
      */
@@ -491,12 +508,12 @@ class StateManager {
         const cutoffDate = new Date();
         cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
         // Clean up completed/failed workflows
-        const workflows = this.listWorkflows();
+        const workflows = this.workflow.list();
         for (const workflow of workflows) {
             if ((workflow.status === 'completed' || workflow.status === 'failed') &&
                 new Date(workflow.updated_at) < cutoffDate) {
                 try {
-                    this.deleteWorkflow(workflow.workflow_id);
+                    this.workflow.delete(workflow.workflow_id);
                     result.deleted++;
                 }
                 catch (error) {
@@ -512,6 +529,128 @@ class StateManager {
     getStateDir() {
         return this.stateDir;
     }
+    // =========================================================================
+    // Deprecated Methods (Backwards Compatibility)
+    // =========================================================================
+    /** @deprecated Use state.workflow.create() instead. Will be removed in v2.0 */
+    createWorkflow(workId) {
+        console.warn('DEPRECATED: StateManager.createWorkflow() is deprecated. Use state.workflow.create() instead.');
+        return this.workflow.create(workId);
+    }
+    /** @deprecated Use state.workflow.save() instead. Will be removed in v2.0 */
+    saveWorkflow(state) {
+        console.warn('DEPRECATED: StateManager.saveWorkflow() is deprecated. Use state.workflow.save() instead.');
+        return this.workflow.save(state);
+    }
+    /** @deprecated Use state.workflow.get() instead. Will be removed in v2.0 */
+    getWorkflow(workflowId) {
+        console.warn('DEPRECATED: StateManager.getWorkflow() is deprecated. Use state.workflow.get() instead.');
+        return this.workflow.get(workflowId);
+    }
+    /** @deprecated Use state.workflow.getActive() instead. Will be removed in v2.0 */
+    getActiveWorkflow(workId) {
+        console.warn('DEPRECATED: StateManager.getActiveWorkflow() is deprecated. Use state.workflow.getActive() instead.');
+        return this.workflow.getActive(workId);
+    }
+    /** @deprecated Use state.workflow.list() instead. Will be removed in v2.0 */
+    listWorkflows(options) {
+        console.warn('DEPRECATED: StateManager.listWorkflows() is deprecated. Use state.workflow.list() instead.');
+        return this.workflow.list(options);
+    }
+    /** @deprecated Use state.workflow.delete() instead. Will be removed in v2.0 */
+    deleteWorkflow(workflowId) {
+        console.warn('DEPRECATED: StateManager.deleteWorkflow() is deprecated. Use state.workflow.delete() instead.');
+        return this.workflow.delete(workflowId);
+    }
+    /** @deprecated Use state.workflow.pause() instead. Will be removed in v2.0 */
+    pauseWorkflow(workflowId) {
+        console.warn('DEPRECATED: StateManager.pauseWorkflow() is deprecated. Use state.workflow.pause() instead.');
+        return this.workflow.pause(workflowId);
+    }
+    /** @deprecated Use state.workflow.resume() instead. Will be removed in v2.0 */
+    resumeWorkflow(workflowId) {
+        console.warn('DEPRECATED: StateManager.resumeWorkflow() is deprecated. Use state.workflow.resume() instead.');
+        return this.workflow.resume(workflowId);
+    }
+    /** @deprecated Use state.workflow.recover() instead. Will be removed in v2.0 */
+    recoverWorkflow(workflowId, options) {
+        console.warn('DEPRECATED: StateManager.recoverWorkflow() is deprecated. Use state.workflow.recover() instead.');
+        return this.workflow.recover(workflowId, options);
+    }
+    /** @deprecated Use state.phase.update() instead. Will be removed in v2.0 */
+    updatePhase(workflowId, phase, updates, options) {
+        console.warn('DEPRECATED: StateManager.updatePhase() is deprecated. Use state.phase.update() instead.');
+        return this.phase.update(workflowId, phase, updates, options);
+    }
+    /** @deprecated Use state.phase.start() instead. Will be removed in v2.0 */
+    startPhase(workflowId, phase) {
+        console.warn('DEPRECATED: StateManager.startPhase() is deprecated. Use state.phase.start() instead.');
+        return this.phase.start(workflowId, phase);
+    }
+    /** @deprecated Use state.phase.complete() instead. Will be removed in v2.0 */
+    completePhase(workflowId, phase, outputs) {
+        console.warn('DEPRECATED: StateManager.completePhase() is deprecated. Use state.phase.complete() instead.');
+        return this.phase.complete(workflowId, phase, outputs);
+    }
+    /** @deprecated Use state.phase.fail() instead. Will be removed in v2.0 */
+    failPhase(workflowId, phase, error) {
+        console.warn('DEPRECATED: StateManager.failPhase() is deprecated. Use state.phase.fail() instead.');
+        return this.phase.fail(workflowId, phase, error);
+    }
+    /** @deprecated Use state.phase.skip() instead. Will be removed in v2.0 */
+    skipPhase(workflowId, phase, reason) {
+        console.warn('DEPRECATED: StateManager.skipPhase() is deprecated. Use state.phase.skip() instead.');
+        return this.phase.skip(workflowId, phase, reason);
+    }
+    /** @deprecated Use state.checkpoint.create() instead. Will be removed in v2.0 */
+    createCheckpoint(workflowId, phase, step, data) {
+        console.warn('DEPRECATED: StateManager.createCheckpoint() is deprecated. Use state.checkpoint.create() instead.');
+        return this.checkpoint.create(workflowId, phase, step, data);
+    }
+    /** @deprecated Use state.checkpoint.get() instead. Will be removed in v2.0 */
+    getCheckpoint(checkpointId) {
+        console.warn('DEPRECATED: StateManager.getCheckpoint() is deprecated. Use state.checkpoint.get() instead.');
+        return this.checkpoint.get(checkpointId);
+    }
+    /** @deprecated Use state.checkpoint.list() instead. Will be removed in v2.0 */
+    listCheckpoints(workflowId) {
+        console.warn('DEPRECATED: StateManager.listCheckpoints() is deprecated. Use state.checkpoint.list() instead.');
+        return this.checkpoint.list(workflowId);
+    }
+    /** @deprecated Use state.checkpoint.getLatest() instead. Will be removed in v2.0 */
+    getLatestCheckpoint(workflowId) {
+        console.warn('DEPRECATED: StateManager.getLatestCheckpoint() is deprecated. Use state.checkpoint.getLatest() instead.');
+        return this.checkpoint.getLatest(workflowId);
+    }
+    /** @deprecated Use state.manifest.create() instead. Will be removed in v2.0 */
+    createManifest(workflowId, workId) {
+        console.warn('DEPRECATED: StateManager.createManifest() is deprecated. Use state.manifest.create() instead.');
+        return this.manifest.create(workflowId, workId);
+    }
+    /** @deprecated Use state.manifest.save() instead. Will be removed in v2.0 */
+    saveManifest(manifest) {
+        console.warn('DEPRECATED: StateManager.saveManifest() is deprecated. Use state.manifest.save() instead.');
+        return this.manifest.save(manifest);
+    }
+    /** @deprecated Use state.manifest.get() instead. Will be removed in v2.0 */
+    getManifest(manifestId) {
+        console.warn('DEPRECATED: StateManager.getManifest() is deprecated. Use state.manifest.get() instead.');
+        return this.manifest.get(manifestId);
+    }
+    /** @deprecated Use state.manifest.addPhase() instead. Will be removed in v2.0 */
+    addPhaseToManifest(manifestId, phaseManifest) {
+        console.warn('DEPRECATED: StateManager.addPhaseToManifest() is deprecated. Use state.manifest.addPhase() instead.');
+        return this.manifest.addPhase(manifestId, phaseManifest);
+    }
+    /** @deprecated Use state.manifest.addArtifact() instead. Will be removed in v2.0 */
+    addArtifactToManifest(manifestId, artifact) {
+        console.warn('DEPRECATED: StateManager.addArtifactToManifest() is deprecated. Use state.manifest.addArtifact() instead.');
+        return this.manifest.addArtifact(manifestId, artifact);
+    }
+    /** @deprecated Use state.manifest.complete() instead. Will be removed in v2.0 */
+    completeManifest(manifestId, status) {
+        console.warn('DEPRECATED: StateManager.completeManifest() is deprecated. Use state.manifest.complete() instead.');
+        return this.manifest.complete(manifestId, status);
+    }
 }
-exports.StateManager = StateManager;
 //# sourceMappingURL=manager.js.map