npm install stateset-node
# or
# yarn add stateset-node

# Example for bash/zsh shells. Adapt for your environment (e.g., .env file, secrets manager).
export STATESET_API_KEY='your_api_key_here'

import { stateset } from 'stateset-node';
import winston from 'winston';

// Configure structured logging
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ filename: 'manufacturing.log' }),
    new winston.transports.Console()
  ]
});

// Ensure the environment variable is loaded (e.g., using dotenv)
if (!process.env.STATESET_API_KEY) {
  throw new Error("STATESET_API_KEY environment variable is not set.");
}

// Initialize the client
const client = new stateset(process.env.STATESET_API_KEY);

// Optional: Verify API connectivity on startup
async function verifyApiConnection() {
  try {
    const health = await client.system.healthCheck();
    logger.info('StateSet API connection verified', { status: health.status, timestamp: new Date().toISOString() });
    if (health.status !== 'OK') {
        logger.warn('API health check returned non-OK status', { health });
    }
  } catch (error) {
    logger.error('Failed to connect to StateSet API', { error: error.message, stack: error.stack });
    // Consider application-specific error handling (e.g., retry, exit)
  }
}

verifyApiConnection();

/**
 * Creates a new Product definition in Stateset.
 * @param {object} productData - Attributes for the new product.
 * @returns {Promise<object>} The newly created Product object.
 */
async function createProduct(productData) {
    try {
        console.log('Creating product:', productData.sku);
        const newProduct = await client.product.create({
            name: productData.name,
            description: productData.description,
            sku: productData.sku, 
            unit_of_measure: productData.unit_of_measure,
            type: productData.type,
            category: productData.category,
            sub_category: productData.sub_category,
            brand: productData.brand,
            model_number: productData.model_number,
            serial_number: productData.serial_number,
            weight: productData.weight,
            weight_unit: productData.weight_unit,
            dimensions: productData.dimensions,
            dimensions_unit: productData.dimensions_unit,
            color: productData.color,
            material: productData.material
        });
        console.log(`Product created successfully: ID=${newProduct.id}, SKU=${newProduct.sku}`);
        return newProduct;
    } catch (error) {
        console.error(`Error creating product ${productData.sku}:`, error.response ? error.response.data : error.message);
        throw error; // Re-throw for upstream handling
    }
}

// Example Usage:
const widgetProductData = {
  name: 'Standard Widget',
  description: 'A reliable widget for general use.',
  sku: 'SW-100',
  unit_of_measure: 'pcs',
  type: 'manufactured',
  category: 'Electronics',
  sub_category: 'Widgets',
  brand: 'Acme',
  model_number: 'SW-100',
  serial_number: '1234567890',
};

const product = await createProduct(widgetProductData);

/**
 * Creates a Bill of Materials (BOM) for a specific Product.
 * @param {object} bomData - Attributes for the new BOM.
 * @param {string} bomData.productId - ID of the Product this BOM is for.
 * @param {Array<object>} bomData.components - Array of { item_id, quantity, unit }.
 * @returns {Promise<object>} The newly created BOM object.
 */
async function createBOM(bomData) {
    try {
        console.log(`Creating BOM for Product ID: ${bomData.productId}`);
        const newBOM = await client.billofmaterials.create({
            name: bomData.name || `BOM for Product ${bomData.productId}`,
            description: bomData.description,
            product_id: bomData.productId,
            version: bomData.version || '1.0', // Implement versioning as needed
            components: bomData.components,
            is_active: bomData.is_active || true,
            effective_date: bomData.effective_date || new Date().toISOString(),
            expiration_date: bomData.expiration_date || null,
            is_active: bomData.is_active || true,
            // Add other fields: isActive, effective_date, etc.
        });
        console.log(`BOM created successfully: ID=${newBOM.id}, Name=${newBOM.name}`);
        return newBOM;
    } catch (error) {
        console.error(`Error creating BOM for Product ID ${bomData.productId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage (using 'product' from previous step):
 const widgetBOMData = {
    productId: product.id,
    name: 'Standard Widget BOM v1.0',
    description: 'Components for SW-100',
    version: '1.0',
    components: [
        { item_id: 'COMP-A', quantity: 2, unit: 'pcs' }, // Assumes COMP-A exists as a Product/Item
        { item_id: 'COMP-B', quantity: 50, unit: 'g' }  // Assumes COMP-B exists as a Product/Item
    ]
};

const bom = await createBOM(widgetBOMData);

/**
 * Creates a Work Order to plan the production of a Product.
 * @param {object} woData - Attributes for the new Work Order.
 * @param {string} woData.bomId - ID of the BOM to use for this production run.
 * @param {string} woData.productId - ID of the product being manufactured.
 * @param {number} woData.quantity - Target quantity to produce.
 * @returns {Promise<object>} The newly created Work Order object.
 */
async function createWorkOrder(woData) {
    try {
        console.log(`Creating Work Order for Product ID: ${woData.productId}, Qty: ${woData.quantity}`);
        const newWorkOrder = await client.workorder.create({
            type: woData.type || 'production', // 'production', 'rework', etc.
            status: woData.status || 'planned', // 'planned', 'released', 'in_progress', 'completed'
            priority: woData.priority || 'medium',
            number: woData.number || `WO-${Date.now()}`, // Ensure uniqueness
            site: woData.site, // Manufacturing location identifier
            product_id: woData.productId, // What is being made
            quantity: woData.quantity,   // How many
            due_date: woData.dueDate, // ISO 8601 string
            bill_of_material_id: woData.bomId, // Which recipe to use
            is_active: woData.is_active || true,
            effective_date: woData.effective_date || new Date().toISOString(),
            expiration_date: woData.expiration_date || null,
            work_order_line_items: woData.work_order_line_items || []
        });
        console.log(`Work Order created successfully: ID=${newWorkOrder.id}, Number=${newWorkOrder.number}`);
        return newWorkOrder;
    } catch (error) {
        console.error(`Error creating Work Order for Product ID ${woData.productId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage (using 'product' and 'bom' from previous steps):
const widgetWOData = {
  productId: product.id,
  bomId: bom.id,
  quantity: 500,
  dueDate: new Date(Date.now() + 14 * 86400000).toISOString(), // Due in 14 days
  site: 'FACTORY-A',
  number: 'WO-SW100-500'
};

const workOrder = await createWorkOrder(widgetWOData);

/**
 * Creates a Manufacturing Order to track the execution of a Work Order.
 * @param {object} moData - Attributes for the new Manufacturing Order.
 * @param {string} moData.workOrderId - ID of the parent Work Order.
 * @returns {Promise<object>} The newly created Manufacturing Order object.
 */
async function createManufacturingOrder(moData) {
    try {
        console.log(`Creating Manufacturing Order linked to WO ID: ${moData.workOrderId}`);
        // Often MO details are derived from the WO initially
        const parentWO = await client.workorder.get(moData.workOrderId); // Fetch WO details if needed

        const newMO = await client.manufacturingorder.create({
            type: moData.type || parentWO.type || 'production',
            status: moData.status || 'released', // Often starts as 'released' or 'in_progress'
            priority: moData.priority || parentWO.priority || 'medium',
            number: moData.number || `MO-${parentWO.number || Date.now()}`, // Ensure uniqueness
            site: moData.site || parentWO.site,
            work_order_id: moData.workOrderId,
            product_id: parentWO.product_id, // Inherited from WO
            quantity_planned: parentWO.quantity, // Inherited from WO
            manufacturing_order_line_items: moData.manufacturing_order_line_items || [],
            is_active: moData.is_active || true,
            effective_date: moData.effective_date || new Date().toISOString(),
            expiration_date: moData.expiration_date || null,
            actual_start_date: new Date().toISOString(), // Can set start time immediately
        });
        console.log(`Manufacturing Order created successfully: ID=${newMO.id}, Number=${newMO.number}`);
        return newMO;
    } catch (error) {
        console.error(`Error creating Manufacturing Order for WO ID ${moData.workOrderId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage (using 'workOrder' from previous step):
const widgetMOData = {
  workOrderId: workOrder.id,
  status: 'released' // Ready to start picking/production
};
const manufacturingOrder = await createManufacturingOrder(widgetMOData);

/**
 * Logs runtime for a specific machine against a Manufacturing Order.
 * @param {string} machineId - The ID of the machine used.
 * @param {string} moId - The ID of the Manufacturing Order.
 * @param {object} runtimeData - { start_time, end_time, cycle_count (optional) }.
 * @returns {Promise<object>} The created machine runtime log entry.
 */
async function logMachineRuntime(machineId, moId, runtimeData) {
    try {
        console.log(`Logging runtime for Machine ID: ${machineId} on MO ID: ${moId}`);
        // Assuming a dedicated endpoint exists like 'client.machines.logRuntime' or similar
        // This is a hypothetical structure; adapt to the actual SDK method.
        const runtimeLog = await client.machines.logRuntime(machineId, { // Adapt SDK call
            manufacturing_order_id: moId,
            start_time: runtimeData.start_time, // ISO 8601 string
            end_time: runtimeData.end_time,     // ISO 8601 string
            is_active: runtimeData.is_active || true,
          
        });
        console.log(`Machine runtime logged successfully: Log ID=${runtimeLog.id}`);
        return runtimeLog;
    } catch (error) {
        console.error(`Error logging runtime for Machine ${machineId} on MO ${moId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

/**
 * Records waste or scrap generated during a Manufacturing Order.
 * @param {string} moId - The ID of the Manufacturing Order.
 * @param {object} wasteData - { item_id, quantity, unit, reason, type ('waste'/'scrap') }.
 * @returns {Promise<object>} The created waste/scrap record.
 */
async function recordWaste(moId, wasteData) {
    try {
        console.log(`Recording ${wasteData.type} for MO ID: ${moId}, Item: ${wasteData.item_id}, Qty: ${wasteData.quantity}`);
        // Assuming an endpoint like 'client.wasteAndScrap.create' exists
        const wasteRecord = await client.wasteAndScrap.create({ // Adapt SDK call
            manufacturing_order_id: moId,
            item_id: wasteData.item_id, // The component part number that was wasted
            quantity: wasteData.quantity,
            unit: wasteData.unit,
            type: wasteData.type, // 'waste', 'scrap'
            reason: wasteData.reason,
            // Optional fields: recorded_by, timestamp, location_id
        });
        console.log(`${wasteData.type} recorded successfully: Record ID=${wasteRecord.id}`);
        // IMPORTANT: This record typically needs a corresponding INVENTORY adjustment
        //            to decrease the quantity of the wasted item_id.
        // await adjustInventoryForWaste(wasteData.item_id, wasteData.quantity, wasteData.unit, moId);
        return wasteRecord;
    } catch (error) {
        console.error(`Error recording ${wasteData.type} for MO ID ${moId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage:
const startTime = new Date();
const endTime = new Date(startTime.getTime() + 2 * 3600000); // 2 hours later
await logMachineRuntime('MACHINE-01', manufacturingOrder.id, {
    start_time: startTime.toISOString(),
    end_time: endTime.toISOString()
});

await recordWaste(manufacturingOrder.id, {
    item_id: 'COMP-A', // Wasted component
    quantity: 5,
    unit: 'pcs',
    type: 'scrap',
    reason: 'Damaged during handling'
});

/**
 * Updates the status of a Manufacturing Order, typically to 'completed'.
 * Records the actual quantity produced.
 * @param {string} moId - The ID of the Manufacturing Order to complete.
 * @param {number} quantityCompleted - The actual quantity of the Product produced.
 * @returns {Promise<object>} The updated Manufacturing Order object.
 */
async function completeManufacturingOrder(moId, quantityCompleted) {
    try {
        console.log(`Completing Manufacturing Order ID: ${moId}, Qty Produced: ${quantityCompleted}`);
        const updatedMO = await client.manufacturingorder.update(moId, {
            status: 'completed',
            actual_end_date: new Date().toISOString(),
            quantity_completed: quantityCompleted,
            // Potentially update line items with actual consumption if tracked there
        });
        console.log(`Manufacturing Order ${moId} completed successfully.`);
        // IMPORTANT: MO completion usually triggers Finished Goods Inventory receipt.
        // await receiveFinishedGoods(updatedMO.product_id, quantityCompleted, moId);
        return updatedMO;
    } catch (error) {
        console.error(`Error completing Manufacturing Order ${moId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage:
const actualQuantityProduced = 495; // Perhaps 5 units were scrapped
const completedMO = await completeManufacturingOrder(manufacturingOrder.id, actualQuantityProduced);

/**
 * Creates a Pick task for required inventory items for an MO.
 * @param {string} moId - The Manufacturing Order needing materials.
 * @param {Array<object>} itemsToPick - Array of { inventory_item_id, quantity, unit }.
 * @returns {Promise<object>} The created Pick task object.
 */
async function createPickTask(moId, itemsToPick) {
    try {
        console.log(`Creating Pick Task for MO ID: ${moId}`);
        // Assumes an endpoint like 'client.picks.create' exists
        const newPick = await client.picks.create({ // Adapt SDK call
            manufacturing_order_id: moId,
            status: 'pending', // 'pending', 'in_progress', 'completed', 'cancelled'
            // Optional: picker_id, requested_date, priority
            items: itemsToPick.map(item => ({
                 inventory_item_id: item.inventory_item_id, // Specific stock ID
                 quantity_requested: item.quantity,
                 unit: item.unit
                
             }))
        });
        console.log(`Pick Task created successfully: ID=${newPick.id}`);
        return newPick;
    } catch (error) {
        console.error(`Error creating Pick Task for MO ID ${moId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

/**
 * Marks a Pick task as completed, recording actual picked quantities.
 * @param {string} pickId - The ID of the Pick task to complete.
 * @param {Array<object>} itemsPicked - Array of { inventory_item_id, quantity_picked }.
 * @returns {Promise<object>} The updated Pick task object.
 */
async function completePickTask(pickId, itemsPicked) {
    try {
        console.log(`Completing Pick Task ID: ${pickId}`);
        // Assumes an endpoint like 'client.picks.complete' or 'client.picks.update' exists
        const completedPick = await client.picks.update(pickId, { // Adapt SDK call
            status: 'completed',
            completed_date: new Date().toISOString(),
            // Update line items with actual picked quantities
            items: itemsPicked.map(item => ({
                 inventory_item_id: item.inventory_item_id,
                 quantity_picked: item.quantity_picked
                
             }))
        });
        console.log(`Pick Task ${pickId} completed successfully.`);

        for (const item of itemsPicked) {
           await adjustInventoryForPick(item.inventory_item_id, item.quantity_picked);
        }
        return completedPick;
    } catch (error) {
        console.error(`Error completing Pick Task ${pickId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage:
const pickItems = [
    { inventory_item_id: 'INV-CA-001', quantity: 2, unit: 'pcs' },
    { inventory_item_id: 'INV-CB-005', quantity: 50, unit: 'g' }
];

const pickTask = await createPickTask(manufacturingOrder.id, pickItems);

// Later, when picked: Assume only 48g of COMP-B was available/picked
const pickedQuantities = [
    { inventory_item_id: 'INV-CA-001', quantity_picked: 2 },
    { inventory_item_id: 'INV-CB-005', quantity_picked: 48 }
];
const completedPick = await completePickTask(pickTask.id, pickedQuantities);

/**
 * Creates an inventory movement record for receiving finished goods.
 * Often triggered after MO completion.
 * @param {string} productId - The Product ID (SKU) of the item produced.
 * @param {number} quantity - The quantity produced and received into stock.
 * @param {string} sourceMoId - The Manufacturing Order ID that produced these goods.
 * @returns {Promise<object>} The created inventory movement record.
 */
async function receiveFinishedGoods(productId, quantity, sourceMoId) {
    try {
        console.log(`Receiving Finished Goods: Product ID=${productId}, Qty=${quantity} from MO ID=${sourceMoId}`);
        // Assumes a general inventory adjustment/movement endpoint
        const inventoryReceipt = await client.inventory.create({ // Adapt SDK call
            part_number: productId, // Or item_id
            quantity: quantity, // Positive quantity for receipt
            type: 'FG_RECEIPT', // Categorize the movement type
            source_document_id: sourceMoId,
            source_document_type: 'ManufacturingOrder',
            // Important: Determine the UNIT COST of these finished goods
            // This involves summing material, labor, overhead costs from the MO.
            // unit_cost: calculateFinishedGoodsCost(sourceMoId), // Requires separate calculation
            location_id: 'FG-WAREHOUSE', // Target location
            // Add lot/batch number if applicable
        });
        console.log(`Finished Goods received into inventory: Movement ID=${inventoryReceipt.id}`);
        return inventoryReceipt;
    } catch (error) {
        console.error(`Error receiving Finished Goods for Product ${productId} from MO ${sourceMoId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage (called after completeManufacturingOrder):
await receiveFinishedGoods(completedMO.product_id, completedMO.quantity_completed, completedMO.id);

/**
 * Schedules a Cycle Count task for specific items or locations.
 * @param {object} countData - { scheduled_date, location_id, item_ids (optional) }.
 * @returns {Promise<object>} The created Cycle Count task object.
 */
async function scheduleCycleCount(countData) {
    try {
        console.log(`Scheduling Cycle Count for Location: ${countData.location_id}`);
        // Assumes an endpoint like 'client.cycleCounts.create' exists
        const newCycleCount = await client.cycleCounts.create({ // Adapt SDK call
            scheduled_date: countData.scheduled_date, // ISO 8601 string
            location_id: countData.location_id, // ID of the warehouse area being counted
            status: 'scheduled', // 'scheduled', 'in_progress', 'completed'
            // Optionally specify items or count everything in the location
            items_to_count: countData.item_ids || [], // Array of part_numbers/item_ids
        });
        console.log(`Cycle Count scheduled successfully: ID=${newCycleCount.id}`);
        return newCycleCount;
    } catch (error) {
        console.error(`Error scheduling Cycle Count for Location ${countData.location_id}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

/**
 * Records the results of a completed Cycle Count, highlighting discrepancies.
 * @param {string} countId - The ID of the Cycle Count task.
 * @param {Array<object>} countResults - Array of { inventory_item_id, counted_quantity }.
 * @returns {Promise<object>} The updated Cycle Count task object.
 */
async function recordCycleCountResults(countId, countResults) {
    try {
        console.log(`Recording results for Cycle Count ID: ${countId}`);
        // Assumes an endpoint like 'client.cycleCounts.complete' or 'update'
        const completedCount = await client.cycleCounts.update(countId, { // Adapt SDK call
            status: 'completed',
            completion_date: new Date().toISOString(),
            results: countResults.map(result => ({
                 inventory_item_id: result.inventory_item_id, // Specific stock ID counted
                 counted_quantity: result.counted_quantity,
                 // The system should calculate discrepancy based on current inventory qty
                 system_quantity: fetchSystemQuantity(result.inventory_item_id),
                 discrepancy: counted_quantity - system_quantity
             }))
        });
        console.log(`Cycle Count ${countId} results recorded.`);
        // IMPORTANT: Discrepancies found during cycle counts require investigation
        //            and subsequent INVENTORY ADJUSTMENTS to correct system quantities.
        processCycleCountDiscrepancies(completedCount.results);
        return completedCount;
    } catch (error) {
        console.error(`Error recording results for Cycle Count ${countId}:`, error.response ? error.response.data : error.message);
        throw error;
    }
}

// Example Usage:
const tomorrow = new Date(Date.now() + 86400000);
const countTask = await scheduleCycleCount({
    scheduled_date: tomorrow.toISOString(),
    location_id: 'BIN-A1',
    item_ids: ['COMP-A', 'COMP-B'] // Count only these items in this location
});

// After counting:
const results = [
    { inventory_item_id: 'INV-CA-001', counted_quantity: 98 }, // System thought 100?
    { inventory_item_id: 'INV-CB-005', counted_quantity: 50 }  // Matches system?
];
await recordCycleCountResults(countTask.id, results);

// Conceptual OEE Calculation Snippet (Requires fetching related data)
async function calculateOEEForMO(moId) {
    try {
        const mo = await client.manufacturingorder.get(moId);
        if (!mo || mo.status !== 'completed') {
            throw new Error(`Manufacturing Order ${moId} not found or not completed.`);
        }

        // --- Data Gathering (Requires specific queries/logic) ---
        // 1. Planned Time: Derive from MO schedule, associated WO, or standard process times.
        const plannedProductionTimeHrs = 8; // Placeholder

        // 2. Actual Runtime: Sum machine runtime logs linked to this MO.
        const machineLogs = await client.machines.listLogs({ manufacturing_order_id: moId });
        const actualRuntimeHrs = machineLogs.reduce((sum, log) => sum + calculateDurationHrs(log.start_time, log.end_time), 0);

        // 3. Ideal Cycle Time: From Product/Process definition (units per hour).
        const idealCycleTimeHrsPerUnit = 0.01; // Placeholder (e.g., 100 units/hr = 0.01 hrs/unit)

        // 4. Total Pieces Produced: Sum of good pieces and scrap for this MO.
        const scrapRecords = await client.wasteAndScrap.list({ manufacturing_order_id: moId });
        const totalScrapQty = scrapRecords.reduce((sum, record) => sum + record.quantity, 0);
        const goodPieces = mo.quantity_completed;
        const totalPieces = goodPieces + totalScrapQty;

        if (plannedProductionTimeHrs <= 0 || actualRuntimeHrs <= 0 || totalPieces <= 0) {
             console.warn(`Cannot calculate OEE for MO ${moId} due to zero values in time or quantity.`);
             return null;
        }
        // --- Calculation ---
        const availability = actualRuntimeHrs / plannedProductionTimeHrs;
        const performance = (idealCycleTimeHrsPerUnit * totalPieces) / actualRuntimeHrs;
        const quality = goodPieces / totalPieces;

        const oee = availability * performance * quality;

        console.log(`OEE Calculation for MO ${moId}:`);
        console.log(`  Availability: ${(availability * 100).toFixed(1)}%`);
        console.log(`  Performance:  ${(performance * 100).toFixed(1)}%`);
        console.log(`  Quality:      ${(quality * 100).toFixed(1)}%`);
        console.log(`  OEE:          ${(oee * 100).toFixed(1)}%`);

        return { availability, performance, quality, oee };

    } catch (error) {
        console.error(`Error calculating OEE for MO ${moId}:`, error.message);
        return null;
    }
}

// Placeholder helper function
function calculateDurationHrs(startISO, endISO) {
    return (new Date(endISO) - new Date(startISO)) / (1000 * 60 * 60);
}

// Example Usage:
await calculateOEEForMO(completedMO.id);

// Enhanced Error Handling Wrapper Example (from previous guide, still applicable)
async function safeApiOperation(operation, description) {
    try {
        console.log(`Attempting operation: ${description}`);
        const result = await operation();
        // Log success with key identifiers if needed
        // logger.info(`Operation successful: ${description}`, { resultId: result?.id });
        return result;
    } catch (error) {
        const timestamp = new Date().toISOString();
        let errorDetails = {
            message: error.message,
            stack: error.stack?.substring(0, 1000), // Limit stack trace length
            description: description,
            timestamp: timestamp
        };

        if (error.response) {
            errorDetails.apiStatus = error.response.status;
            errorDetails.apiResponse = error.response.data;
        } else {
             errorDetails.type = 'Application Error';
        }

        console.error(`Error during operation: ${description}`, errorDetails);

        // Log structured error to external system
        logger.error('Manufacturing Process Error', errorDetails);

        // Optional: Notify team on critical errors
        // if (errorDetails.apiStatus >= 500 || !errorDetails.apiStatus) {
        //    notifyTeam(`Critical error in ${description}: ${error.message}`);
        // }

        // Re-throw for workflow control or return specific error indicator
        throw new Error(`Operation failed: ${description}. Status: ${errorDetails.apiStatus || 'N/A'}. Message: ${errorDetails.message}`);
    }
}

// Usage Example:
try {
   const product = await safeApiOperation(
       () => createProduct({ name: '...', sku: '...' }),
       'Create Product SW-101'
   );
   // ... other operations
 } catch (workflowError) {
   console.error("Manufacturing workflow step failed:", workflowError.message);
   // Implement workflow recovery or termination logic
}