@gravito/flux 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/index.d.ts

@@ -1,38 +1,43 @@
+import { FluxEngine } from './index.node.js';
+export { ContextManager, FluxConsoleLogger, FluxSilentLogger, JsonFileTraceSink, MemoryStorage, OrbitFlux, OrbitFluxOptions, StateMachine, StepExecutor, WorkflowBuilder, createWorkflow } from './index.node.js';
+import { W as WorkflowDefinition } from './types-DvVHBmP6.js';
+export { F as FluxConfig, a as FluxLogger, b as FluxResult, c as FluxTraceEvent, d as FluxTraceEventType, e as FluxTraceSink, S as StepDefinition, f as StepDescriptor, g as StepExecution, h as StepResult, i as WorkflowContext, j as WorkflowDescriptor, k as WorkflowFilter, l as WorkflowState, m as WorkflowStatus, n as WorkflowStorage } from './types-DvVHBmP6.js';
+export { BunSQLiteStorage, BunSQLiteStorageOptions } from './bun.js';
+import 'bun:sqlite';
+
+interface ProfileMetrics {
+    durationMs: number;
+    cpuUserMs: number;
+    cpuSysMs: number;
+    memDeltaBytes: number;
+    cpuRatio: number;
+}
+interface ProfileRecommendation {
+    type: 'IO_BOUND' | 'CPU_BOUND' | 'MEMORY_BOUND';
+    safeConcurrency: number;
+    efficientConcurrency: number;
+    suggestedConcurrency: string;
+    reason: string;
+}
 /**
- * @fileoverview @gravito/flux - Platform-agnostic Workflow Engine
+ * Workflow Profiler
  *
- * High-performance, type-safe workflow engine with Bun optimizations.
- *
- * @example Basic Usage
- * ```typescript
- * import { FluxEngine, createWorkflow } from '@gravito/flux'
- *
- * const workflow = createWorkflow('order-process')
- *   .input<{ orderId: string }>()
- *   .step('validate', async (ctx) => {
- *     ctx.data.order = await fetchOrder(ctx.input.orderId)
- *   })
- *   .step('process', async (ctx) => {
- *     await processPayment(ctx.data.order)
- *   })
- *   .commit('notify', async (ctx) => {
- *     await sendEmail(ctx.data.order.email)
- *   })
- *
- * const engine = new FluxEngine()
- * const result = await engine.execute(workflow, { orderId: '123' })
- * ```
- *
- * @module @gravito/flux
+ * Analyzes workflow performance characteristics to recommend
+ * optimal concurrency settings for Consumer workers.
  */
-export { createWorkflow, WorkflowBuilder } from './builder/WorkflowBuilder';
-export { ContextManager } from './core/ContextManager';
-export { StateMachine } from './core/StateMachine';
-export { StepExecutor } from './core/StepExecutor';
-export { FluxEngine } from './engine/FluxEngine';
-export { FluxConsoleLogger, FluxSilentLogger } from './logger/FluxLogger';
-export { OrbitFlux, type OrbitFluxOptions } from './orbit/OrbitFlux';
-export { BunSQLiteStorage, type BunSQLiteStorageOptions } from './storage/BunSQLiteStorage';
-export { MemoryStorage } from './storage/MemoryStorage';
-export type { FluxConfig, FluxLogger, FluxResult, StepDefinition, StepExecution, StepResult, WorkflowContext, WorkflowDefinition, WorkflowFilter, WorkflowState, WorkflowStatus, WorkflowStorage, } from './types';
-//# sourceMappingURL=index.d.ts.map
+declare class WorkflowProfiler {
+    private engine?;
+    constructor(engine?: FluxEngine | undefined);
+    /**
+     * Run a profile session for a specific workflow
+     */
+    profile<TInput>(workflow: WorkflowDefinition<TInput, any>, input: TInput): Promise<ProfileMetrics>;
+    /**
+     * Generate recommendations based on metrics and current environment
+     */
+    recommend(metrics: ProfileMetrics, config?: {
+        configuredConcurrency?: number;
+    }): ProfileRecommendation;
+}
+
+export { FluxEngine, type ProfileMetrics, type ProfileRecommendation, WorkflowDefinition, WorkflowProfiler };

package/dist/index.js

@@ -1,479 +1,121 @@
-// @bun
+import {
+  ContextManager,
+  FluxConsoleLogger,
+  FluxEngine,
+  FluxSilentLogger,
+  JsonFileTraceSink,
+  MemoryStorage,
+  OrbitFlux,
+  StateMachine,
+  StepExecutor,
+  WorkflowBuilder,
+  createWorkflow
+} from "./chunk-J37UUMLM.js";
 import {
   BunSQLiteStorage
-} from "./chunk-qjdtqchy.js";
-
-// src/builder/WorkflowBuilder.ts
-class WorkflowBuilder {
-  _name;
-  _steps = [];
-  _validateInput;
-  constructor(name) {
-    this._name = name;
-  }
-  input() {
-    return this;
-  }
-  validate(validator) {
-    this._validateInput = validator;
-    return this;
-  }
-  step(name, handler, options) {
-    this._steps.push({
-      name,
-      handler,
-      retries: options?.retries,
-      timeout: options?.timeout,
-      when: options?.when,
-      commit: false
-    });
-    return this;
-  }
-  commit(name, handler, options) {
-    this._steps.push({
-      name,
-      handler,
-      retries: options?.retries,
-      timeout: options?.timeout,
-      when: options?.when,
-      commit: true
-    });
-    return this;
-  }
-  build() {
-    if (this._steps.length === 0) {
-      throw new Error(`Workflow "${this._name}" has no steps`);
-    }
-    return {
-      name: this._name,
-      steps: [...this._steps],
-      validateInput: this._validateInput
-    };
-  }
-  get name() {
-    return this._name;
-  }
-  get stepCount() {
-    return this._steps.length;
-  }
-}
-function createWorkflow(name) {
-  return new WorkflowBuilder(name);
-}
-// src/core/ContextManager.ts
-function generateId() {
-  return crypto.randomUUID();
-}
-
-class ContextManager {
-  create(name, input, stepCount) {
-    const history = Array.from({ length: stepCount }, (_, _i) => ({
-      name: "",
-      status: "pending",
-      retries: 0
-    }));
-    return {
-      id: generateId(),
-      name,
-      input,
-      data: {},
-      status: "pending",
-      currentStep: 0,
-      history
-    };
-  }
-  restore(state) {
-    return {
-      id: state.id,
-      name: state.name,
-      input: state.input,
-      data: { ...state.data },
-      status: state.status,
-      currentStep: state.currentStep,
-      history: state.history.map((h) => ({ ...h }))
-    };
-  }
-  toState(ctx) {
-    return {
-      id: ctx.id,
-      name: ctx.name,
-      status: ctx.status,
-      input: ctx.input,
-      data: { ...ctx.data },
-      currentStep: ctx.currentStep,
-      history: ctx.history.map((h) => ({ ...h })),
-      createdAt: new Date,
-      updatedAt: new Date
-    };
-  }
-  updateStatus(ctx, status) {
-    return {
-      ...ctx,
-      status
-    };
-  }
-  advanceStep(ctx) {
-    return {
-      ...ctx,
-      currentStep: ctx.currentStep + 1
-    };
-  }
-  setStepName(ctx, index, name) {
-    if (ctx.history[index]) {
-      ctx.history[index].name = name;
-    }
-  }
-}
-// src/core/StateMachine.ts
-var TRANSITIONS = {
-  pending: ["running", "failed"],
-  running: ["paused", "completed", "failed"],
-  paused: ["running", "failed"],
-  completed: [],
-  failed: ["pending"]
-};
+} from "./chunk-ZAMVC732.js";
 
-class StateMachine extends EventTarget {
-  _status = "pending";
-  get status() {
-    return this._status;
-  }
-  canTransition(to) {
-    return TRANSITIONS[this._status].includes(to);
-  }
-  transition(to) {
-    if (!this.canTransition(to)) {
-      throw new Error(`Invalid state transition: ${this._status} \u2192 ${to}`);
+// src/profiler/WorkflowProfiler.ts
+import * as os from "os";
+var WorkflowProfiler = class {
+  constructor(engine) {
+    this.engine = engine;
+    if (!this.engine) {
+      this.engine = new FluxEngine({
+        logger: new FluxSilentLogger()
+      });
     }
-    const from = this._status;
-    this._status = to;
-    this.dispatchEvent(new CustomEvent("transition", {
-      detail: { from, to }
-    }));
-  }
-  forceStatus(status) {
-    this._status = status;
-  }
-  isTerminal() {
-    return this._status === "completed" || this._status === "failed";
   }
-  canExecute() {
-    return this._status === "pending" || this._status === "paused";
-  }
-}
-// src/core/StepExecutor.ts
-class StepExecutor {
-  defaultRetries;
-  defaultTimeout;
-  constructor(options = {}) {
-    this.defaultRetries = options.defaultRetries ?? 3;
-    this.defaultTimeout = options.defaultTimeout ?? 30000;
-  }
-  async execute(step, ctx, execution) {
-    const maxRetries = step.retries ?? this.defaultRetries;
-    const timeout = step.timeout ?? this.defaultTimeout;
-    const startTime = Date.now();
-    if (step.when && !step.when(ctx)) {
-      execution.status = "skipped";
-      return {
-        success: true,
-        duration: 0
-      };
+  /**
+   * Run a profile session for a specific workflow
+   */
+  async profile(workflow, input) {
+    try {
+      await this.engine.execute(workflow, input);
+    } catch {
     }
-    execution.status = "running";
-    execution.startedAt = new Date;
-    let lastError;
-    for (let attempt = 0;attempt <= maxRetries; attempt++) {
-      execution.retries = attempt;
-      try {
-        await this.executeWithTimeout(step.handler, ctx, timeout);
-        execution.status = "completed";
-        execution.completedAt = new Date;
-        execution.duration = Date.now() - startTime;
-        return {
-          success: true,
-          duration: execution.duration
-        };
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (attempt < maxRetries) {
-          await this.sleep(Math.min(1000 * 2 ** attempt, 1e4));
-        }
-      }
+    if (global.gc) {
+      global.gc();
     }
-    execution.status = "failed";
-    execution.completedAt = new Date;
-    execution.duration = Date.now() - startTime;
-    execution.error = lastError?.message;
+    const startCpu = process.cpuUsage();
+    const startMem = process.memoryUsage().heapUsed;
+    const startTime = process.hrtime.bigint();
+    await this.engine.execute(workflow, input);
+    const endTime = process.hrtime.bigint();
+    const endCpu = process.cpuUsage(startCpu);
+    const endMem = process.memoryUsage().heapUsed;
+    const durationNs = Number(endTime - startTime);
+    const durationMs = durationNs / 1e6;
+    const cpuUserMs = endCpu.user / 1e3;
+    const cpuSysMs = endCpu.system / 1e3;
+    const totalCpuMs = cpuUserMs + cpuSysMs;
+    const memDeltaBytes = Math.max(0, endMem - startMem);
+    const cpuRatio = totalCpuMs / durationMs;
     return {
-      success: false,
-      error: lastError,
-      duration: execution.duration
+      durationMs,
+      cpuUserMs,
+      cpuSysMs,
+      memDeltaBytes,
+      cpuRatio
     };
   }
-  async executeWithTimeout(handler, ctx, timeout) {
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error("Step timeout")), timeout);
-    });
-    await Promise.race([Promise.resolve(handler(ctx)), timeoutPromise]);
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-}
-// src/storage/MemoryStorage.ts
-class MemoryStorage {
-  store = new Map;
-  async save(state) {
-    this.store.set(state.id, {
-      ...state,
-      updatedAt: new Date
-    });
-  }
-  async load(id) {
-    return this.store.get(id) ?? null;
-  }
-  async list(filter) {
-    let results = Array.from(this.store.values());
-    if (filter?.name) {
-      results = results.filter((s) => s.name === filter.name);
-    }
-    if (filter?.status) {
-      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-      results = results.filter((s) => statuses.includes(s.status));
-    }
-    results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-    if (filter?.offset) {
-      results = results.slice(filter.offset);
-    }
-    if (filter?.limit) {
-      results = results.slice(0, filter.limit);
-    }
-    return results;
-  }
-  async delete(id) {
-    this.store.delete(id);
-  }
-  async init() {}
-  async close() {
-    this.store.clear();
-  }
-  size() {
-    return this.store.size;
-  }
-}
-
-// src/engine/FluxEngine.ts
-class FluxEngine {
-  storage;
-  executor;
-  contextManager;
-  config;
-  constructor(config = {}) {
-    this.config = config;
-    this.storage = config.storage ?? new MemoryStorage;
-    this.executor = new StepExecutor({
-      defaultRetries: config.defaultRetries,
-      defaultTimeout: config.defaultTimeout
-    });
-    this.contextManager = new ContextManager;
-  }
-  async execute(workflow, input) {
-    const startTime = Date.now();
-    const definition = workflow instanceof WorkflowBuilder ? workflow.build() : workflow;
-    if (definition.validateInput && !definition.validateInput(input)) {
-      throw new Error(`Invalid input for workflow "${definition.name}"`);
-    }
-    const ctx = this.contextManager.create(definition.name, input, definition.steps.length);
-    const stateMachine = new StateMachine;
-    await this.storage.save(this.contextManager.toState(ctx));
-    try {
-      stateMachine.transition("running");
-      Object.assign(ctx, { status: "running" });
-      for (let i = 0;i < definition.steps.length; i++) {
-        const step = definition.steps[i];
-        const execution = ctx.history[i];
-        this.contextManager.setStepName(ctx, i, step.name);
-        Object.assign(ctx, { currentStep: i });
-        this.config.on?.stepStart?.(step.name, ctx);
-        const result = await this.executor.execute(step, ctx, execution);
-        if (result.success) {
-          this.config.on?.stepComplete?.(step.name, ctx, result);
-        } else {
-          this.config.on?.stepError?.(step.name, ctx, result.error);
-          stateMachine.transition("failed");
-          Object.assign(ctx, { status: "failed" });
-          await this.storage.save({
-            ...this.contextManager.toState(ctx),
-            error: result.error?.message
-          });
-          return {
-            id: ctx.id,
-            status: "failed",
-            data: ctx.data,
-            history: ctx.history,
-            duration: Date.now() - startTime,
-            error: result.error
-          };
-        }
-        await this.storage.save(this.contextManager.toState(ctx));
-      }
-      stateMachine.transition("completed");
-      Object.assign(ctx, { status: "completed" });
-      await this.storage.save({
-        ...this.contextManager.toState(ctx),
-        completedAt: new Date
-      });
-      this.config.on?.workflowComplete?.(ctx);
-      return {
-        id: ctx.id,
-        status: "completed",
-        data: ctx.data,
-        history: ctx.history,
-        duration: Date.now() - startTime
-      };
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.config.on?.workflowError?.(ctx, err);
-      stateMachine.forceStatus("failed");
-      Object.assign(ctx, { status: "failed" });
-      await this.storage.save({
-        ...this.contextManager.toState(ctx),
-        error: err.message
-      });
-      return {
-        id: ctx.id,
-        status: "failed",
-        data: ctx.data,
-        history: ctx.history,
-        duration: Date.now() - startTime,
-        error: err
-      };
+  /**
+   * Generate recommendations based on metrics and current environment
+   */
+  recommend(metrics, config) {
+    const totalMem = os.totalmem();
+    const cpus2 = os.cpus().length;
+    let type = "IO_BOUND";
+    if (metrics.cpuRatio > 0.5) {
+      type = "CPU_BOUND";
+    } else if (metrics.memDeltaBytes > 50 * 1024 * 1024) {
+      type = "MEMORY_BOUND";
     }
-  }
-  async resume(workflowId) {
-    const state = await this.storage.load(workflowId);
-    if (!state) {
-      return null;
+    const safeMem = totalMem * 0.7;
+    const perInstanceMem = Math.max(metrics.memDeltaBytes, 1024 * 1024);
+    const maxMemConcurrency = Math.floor(safeMem / perInstanceMem);
+    const cpuEfficiencyFactor = 1 / Math.max(metrics.cpuRatio, 1e-3);
+    const maxCpuConcurrency = Math.floor(cpus2 * cpuEfficiencyFactor);
+    const safe = Math.min(maxMemConcurrency, 200);
+    let efficient = Math.min(maxCpuConcurrency, 200);
+    if (type === "CPU_BOUND") {
+      efficient = cpus2;
     }
-    throw new Error("Resume not yet implemented");
-  }
-  async get(workflowId) {
-    return this.storage.load(workflowId);
-  }
-  async list(filter) {
-    return this.storage.list(filter);
-  }
-  async init() {
-    await this.storage.init?.();
-  }
-  async close() {
-    await this.storage.close?.();
-  }
-}
-// src/logger/FluxLogger.ts
-class FluxConsoleLogger {
-  prefix;
-  constructor(prefix = "[Flux]") {
-    this.prefix = prefix;
-  }
-  debug(message, ...args) {
-    console.debug(`${this.prefix} ${message}`, ...args);
-  }
-  info(message, ...args) {
-    console.info(`${this.prefix} ${message}`, ...args);
-  }
-  warn(message, ...args) {
-    console.warn(`${this.prefix} ${message}`, ...args);
-  }
-  error(message, ...args) {
-    console.error(`${this.prefix} ${message}`, ...args);
-  }
-}
-
-class FluxSilentLogger {
-  debug() {}
-  info() {}
-  warn() {}
-  error() {}
-}
-// src/orbit/OrbitFlux.ts
-class OrbitFlux {
-  options;
-  engine;
-  constructor(options = {}) {
-    this.options = {
-      storage: "memory",
-      exposeAs: "flux",
-      defaultRetries: 3,
-      defaultTimeout: 30000,
-      ...options
-    };
-  }
-  static configure(options = {}) {
-    return new OrbitFlux(options);
-  }
-  async install(core) {
-    const { storage, dbPath, exposeAs, defaultRetries, defaultTimeout, logger } = this.options;
-    let storageAdapter;
-    if (typeof storage === "string") {
-      switch (storage) {
-        case "sqlite":
-          storageAdapter = new BunSQLiteStorage({ path: dbPath });
-          break;
-        default:
-          storageAdapter = new MemoryStorage;
-      }
+    const recommended = Math.min(safe, efficient);
+    let reason = "";
+    if (type === "IO_BOUND") {
+      reason = `Workflow is I/O intensive (CPU usage ${(metrics.cpuRatio * 100).toFixed(1)}%). It is safe to run high concurrency up to ${recommended}.`;
+    } else if (type === "CPU_BOUND") {
+      reason = `Workflow is CPU intensive. Limiting concurrency to match CPU cores (${cpus2}) is recommended to prevent blocking.`;
     } else {
-      storageAdapter = storage;
+      reason = `Workflow consumes significant memory (${(metrics.memDeltaBytes / 1024 / 1024).toFixed(1)}MB). Concurrency limited by available RAM.`;
     }
-    await storageAdapter.init?.();
-    const engineConfig = {
-      storage: storageAdapter,
-      defaultRetries,
-      defaultTimeout,
-      logger: logger ?? {
-        debug: (msg) => core.logger.debug(`[Flux] ${msg}`),
-        info: (msg) => core.logger.info(`[Flux] ${msg}`),
-        warn: (msg) => core.logger.warn(`[Flux] ${msg}`),
-        error: (msg) => core.logger.error(`[Flux] ${msg}`)
-      },
-      on: {
-        stepStart: (step) => {
-          core.hooks.doAction("flux:step:start", { step });
-        },
-        stepComplete: (step, ctx, result) => {
-          core.hooks.doAction("flux:step:complete", { step, ctx, result });
-        },
-        stepError: (step, ctx, error) => {
-          core.hooks.doAction("flux:step:error", { step, ctx, error });
-        },
-        workflowComplete: (ctx) => {
-          core.hooks.doAction("flux:workflow:complete", { ctx });
-        },
-        workflowError: (ctx, error) => {
-          core.hooks.doAction("flux:workflow:error", { ctx, error });
-        }
-      }
+    if (config?.configuredConcurrency && config.configuredConcurrency > recommended) {
+      reason += ` 
+\u26A0\uFE0F Warning: Your current setting (${config.configuredConcurrency}) exceeds the recommended limit (${recommended}).`;
+    }
+    return {
+      type,
+      safeConcurrency: safe,
+      efficientConcurrency: efficient,
+      suggestedConcurrency: `${Math.max(1, Math.floor(recommended * 0.5))} - ${recommended}`,
+      reason
     };
-    this.engine = new FluxEngine(engineConfig);
-    core.services.set(exposeAs, this.engine);
-    core.logger.info(`[OrbitFlux] Initialized (Storage: ${typeof storage === "string" ? storage : "custom"})`);
-  }
-  getEngine() {
-    return this.engine;
   }
-}
+};
 export {
-  createWorkflow,
-  WorkflowBuilder,
-  StepExecutor,
-  StateMachine,
-  OrbitFlux,
-  MemoryStorage,
-  FluxSilentLogger,
-  FluxEngine,
-  FluxConsoleLogger,
+  BunSQLiteStorage,
   ContextManager,
-  BunSQLiteStorage
+  FluxConsoleLogger,
+  FluxEngine,
+  FluxSilentLogger,
+  JsonFileTraceSink,
+  MemoryStorage,
+  OrbitFlux,
+  StateMachine,
+  StepExecutor,
+  WorkflowBuilder,
+  WorkflowProfiler,
+  createWorkflow
 };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/profiler/WorkflowProfiler.ts"],"sourcesContent":["import * as os from 'os'\nimport { FluxEngine } from '../engine/FluxEngine'\nimport { FluxSilentLogger } from '../logger/FluxLogger'\nimport type { WorkflowDefinition } from '../types'\n\nexport interface ProfileMetrics {\n  durationMs: number\n  cpuUserMs: number\n  cpuSysMs: number\n  memDeltaBytes: number\n  cpuRatio: number\n}\n\nexport interface ProfileRecommendation {\n  type: 'IO_BOUND' | 'CPU_BOUND' | 'MEMORY_BOUND'\n  safeConcurrency: number\n  efficientConcurrency: number\n  suggestedConcurrency: string\n  reason: string\n}\n\n/**\n * Workflow Profiler\n *\n * Analyzes workflow performance characteristics to recommend\n * optimal concurrency settings for Consumer workers.\n */\nexport class WorkflowProfiler {\n  constructor(private engine?: FluxEngine) {\n    if (!this.engine) {\n      // Default minimal engine for profiling (Silent)\n      this.engine = new FluxEngine({\n        logger: new FluxSilentLogger(),\n      })\n    }\n  }\n\n  /**\n   * Run a profile session for a specific workflow\n   */\n  async profile<TInput>(\n    workflow: WorkflowDefinition<TInput, any>,\n    input: TInput\n  ): Promise<ProfileMetrics> {\n    // 1. Warmup (JIT)\n    try {\n      await this.engine!.execute(workflow, input)\n    } catch {}\n\n    // 2. Measure\n    if (global.gc) {\n      global.gc()\n    }\n\n    const startCpu = process.cpuUsage()\n    const startMem = process.memoryUsage().heapUsed\n    const startTime = process.hrtime.bigint()\n\n    await this.engine!.execute(workflow, input)\n\n    const endTime = process.hrtime.bigint()\n    const endCpu = process.cpuUsage(startCpu)\n    const endMem = process.memoryUsage().heapUsed\n\n    // 3. Calculate\n    const durationNs = Number(endTime - startTime)\n    const durationMs = durationNs / 1_000_000\n    const cpuUserMs = endCpu.user / 1000\n    const cpuSysMs = endCpu.system / 1000\n    const totalCpuMs = cpuUserMs + cpuSysMs\n    const memDeltaBytes = Math.max(0, endMem - startMem) // Clamp to 0\n\n    // CPU Ratio: How much % of the time was spent on CPU vs Waiting\n    const cpuRatio = totalCpuMs / durationMs\n\n    return {\n      durationMs,\n      cpuUserMs,\n      cpuSysMs,\n      memDeltaBytes,\n      cpuRatio,\n    }\n  }\n\n  /**\n   * Generate recommendations based on metrics and current environment\n   */\n  recommend(\n    metrics: ProfileMetrics,\n    config?: { configuredConcurrency?: number }\n  ): ProfileRecommendation {\n    const totalMem = os.totalmem()\n    const cpus = os.cpus().length\n\n    // 1. Analyze Bottleneck Type\n    let type: ProfileRecommendation['type'] = 'IO_BOUND'\n    if (metrics.cpuRatio > 0.5) {\n      type = 'CPU_BOUND'\n    } else if (metrics.memDeltaBytes > 50 * 1024 * 1024) {\n      // > 50MB per run\n      type = 'MEMORY_BOUND'\n    }\n\n    // 2. Calculate Limits\n\n    // Memory Limit: Keep 30% buffer for system, divide rest by per-workflow memory\n    const safeMem = totalMem * 0.7\n    // Use at least 1MB as baseline to avoid division by zero or huge numbers\n    const perInstanceMem = Math.max(metrics.memDeltaBytes, 1024 * 1024)\n    const maxMemConcurrency = Math.floor(safeMem / perInstanceMem)\n\n    // CPU Limit:\n    // If IO Bound (0.2% cpu), we can run many. 100% / 0.2% = 500 tasks per core.\n    // We cap efficiency at a reasonable number to avoid Event Loop Lag density.\n    const cpuEfficiencyFactor = 1 / Math.max(metrics.cpuRatio, 0.001) // Avoid div by 0\n    const maxCpuConcurrency = Math.floor(cpus * cpuEfficiencyFactor)\n\n    // 3. Synthesize Recommendation\n    const safe = Math.min(maxMemConcurrency, 200) // Hard cap at 200 for sanity\n    let efficient = Math.min(maxCpuConcurrency, 200)\n\n    // If CPU bound, strict limit based on cores\n    if (type === 'CPU_BOUND') {\n      efficient = cpus // 1:1 mapping is best for CPU bound\n    }\n\n    const recommended = Math.min(safe, efficient)\n\n    let reason = ''\n    if (type === 'IO_BOUND') {\n      reason = `Workflow is I/O intensive (CPU usage ${(metrics.cpuRatio * 100).toFixed(1)}%). It is safe to run high concurrency up to ${recommended}.`\n    } else if (type === 'CPU_BOUND') {\n      reason = `Workflow is CPU intensive. Limiting concurrency to match CPU cores (${cpus}) is recommended to prevent blocking.`\n    } else {\n      reason = `Workflow consumes significant memory (${(metrics.memDeltaBytes / 1024 / 1024).toFixed(1)}MB). Concurrency limited by available RAM.`\n    }\n\n    if (config?.configuredConcurrency && config.configuredConcurrency > recommended) {\n      reason += ` \\n⚠️ Warning: Your current setting (${config.configuredConcurrency}) exceeds the recommended limit (${recommended}).`\n    }\n\n    return {\n      type,\n      safeConcurrency: safe,\n      efficientConcurrency: efficient,\n      suggestedConcurrency: `${Math.max(1, Math.floor(recommended * 0.5))} - ${recommended}`,\n      reason,\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA,YAAY,QAAQ;AA2Bb,IAAM,mBAAN,MAAuB;AAAA,EAC5B,YAAoB,QAAqB;AAArB;AAClB,QAAI,CAAC,KAAK,QAAQ;AAEhB,WAAK,SAAS,IAAI,WAAW;AAAA,QAC3B,QAAQ,IAAI,iBAAiB;AAAA,MAC/B,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,QACJ,UACA,OACyB;AAEzB,QAAI;AACF,YAAM,KAAK,OAAQ,QAAQ,UAAU,KAAK;AAAA,IAC5C,QAAQ;AAAA,IAAC;AAGT,QAAI,OAAO,IAAI;AACb,aAAO,GAAG;AAAA,IACZ;AAEA,UAAM,WAAW,QAAQ,SAAS;AAClC,UAAM,WAAW,QAAQ,YAAY,EAAE;AACvC,UAAM,YAAY,QAAQ,OAAO,OAAO;AAExC,UAAM,KAAK,OAAQ,QAAQ,UAAU,KAAK;AAE1C,UAAM,UAAU,QAAQ,OAAO,OAAO;AACtC,UAAM,SAAS,QAAQ,SAAS,QAAQ;AACxC,UAAM,SAAS,QAAQ,YAAY,EAAE;AAGrC,UAAM,aAAa,OAAO,UAAU,SAAS;AAC7C,UAAM,aAAa,aAAa;AAChC,UAAM,YAAY,OAAO,OAAO;AAChC,UAAM,WAAW,OAAO,SAAS;AACjC,UAAM,aAAa,YAAY;AAC/B,UAAM,gBAAgB,KAAK,IAAI,GAAG,SAAS,QAAQ;AAGnD,UAAM,WAAW,aAAa;AAE9B,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,UACE,SACA,QACuB;AACvB,UAAM,WAAc,YAAS;AAC7B,UAAMA,QAAU,QAAK,EAAE;AAGvB,QAAI,OAAsC;AAC1C,QAAI,QAAQ,WAAW,KAAK;AAC1B,aAAO;AAAA,IACT,WAAW,QAAQ,gBAAgB,KAAK,OAAO,MAAM;AAEnD,aAAO;AAAA,IACT;AAKA,UAAM,UAAU,WAAW;AAE3B,UAAM,iBAAiB,KAAK,IAAI,QAAQ,eAAe,OAAO,IAAI;AAClE,UAAM,oBAAoB,KAAK,MAAM,UAAU,cAAc;AAK7D,UAAM,sBAAsB,IAAI,KAAK,IAAI,QAAQ,UAAU,IAAK;AAChE,UAAM,oBAAoB,KAAK,MAAMA,QAAO,mBAAmB;AAG/D,UAAM,OAAO,KAAK,IAAI,mBAAmB,GAAG;AAC5C,QAAI,YAAY,KAAK,IAAI,mBAAmB,GAAG;AAG/C,QAAI,SAAS,aAAa;AACxB,kBAAYA;AAAA,IACd;AAEA,UAAM,cAAc,KAAK,IAAI,MAAM,SAAS;AAE5C,QAAI,SAAS;AACb,QAAI,SAAS,YAAY;AACvB,eAAS,yCAAyC,QAAQ,WAAW,KAAK,QAAQ,CAAC,CAAC,gDAAgD,WAAW;AAAA,IACjJ,WAAW,SAAS,aAAa;AAC/B,eAAS,uEAAuEA,KAAI;AAAA,IACtF,OAAO;AACL,eAAS,0CAA0C,QAAQ,gBAAgB,OAAO,MAAM,QAAQ,CAAC,CAAC;AAAA,IACpG;AAEA,QAAI,QAAQ,yBAAyB,OAAO,wBAAwB,aAAa;AAC/E,gBAAU;AAAA,8CAAwC,OAAO,qBAAqB,oCAAoC,WAAW;AAAA,IAC/H;AAEA,WAAO;AAAA,MACL;AAAA,MACA,iBAAiB;AAAA,MACjB,sBAAsB;AAAA,MACtB,sBAAsB,GAAG,KAAK,IAAI,GAAG,KAAK,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,WAAW;AAAA,MACpF;AAAA,IACF;AAAA,EACF;AACF;","names":["cpus"]}