nvent 0.5.4 → 0.5.6

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.4.1",
+  "version": "0.5.6",
   "configKey": "nvent",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -1,7 +1,7 @@
 import { dirname, join, extname, relative } from 'node:path';
 import { useLogger, defineNuxtModule, createResolver, addTemplate, addTypeTemplate, addServerPlugin, addServerHandler, addServerImports, updateTemplates } from '@nuxt/kit';
 import defu from 'defu';
-import { existsSync, realpathSync } from 'node:fs';
+import { existsSync, realpathSync, readFileSync } from 'node:fs';
 import { globby } from 'globby';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { readFile } from 'node:fs/promises';
@@ -32,6 +32,7 @@ async function loadJsConfig(absPath) {
         emits: flowCfg.emits,
         subscribes,
         triggers: flowCfg.triggers,
+        stepTimeout: flowCfg.stepTimeout,
         awaitBefore: flowCfg.awaitBefore,
         awaitAfter: flowCfg.awaitAfter
       };
@@ -45,7 +46,7 @@ async function loadJsConfig(absPath) {
   } : void 0;
   const workerCfg = cfg?.worker && typeof cfg.worker === "object" ? { ...cfg.worker } : void 0;
   const hasDefaultExport = !!(mod && mod.default);
-  const hasHooks = !!(mod && typeof mod.onAwaitRegister === "function" || mod && typeof mod.onAwaitResolve === "function");
+  const hasHooks = !!(mod && typeof mod.onAwaitRegister === "function" || mod && typeof mod.onAwaitResolve === "function" || mod && typeof mod.onAwaitTimeout === "function");
   return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport, hasHooks };
 }
 
@@ -75,6 +76,7 @@ async function loadTsConfig(absPath) {
           emits: flowCfg.emits,
           subscribes,
           triggers: flowCfg.triggers,
+          stepTimeout: flowCfg.stepTimeout,
           awaitBefore: flowCfg.awaitBefore,
           awaitAfter: flowCfg.awaitAfter
         };
@@ -87,7 +89,7 @@ async function loadTsConfig(absPath) {
       limiter: cfg.queue.limiter
     } : void 0;
     const workerCfg = cfg?.worker && typeof cfg.worker === "object" ? { ...cfg.worker } : void 0;
-    const hasHooks = !!(mod.exports.onAwaitRegister || mod.exports.onAwaitResolve);
+    const hasHooks = !!(mod.exports.onAwaitRegister || mod.exports.onAwaitResolve || mod.exports.onAwaitTimeout);
     return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport, hasHooks };
   } catch (error) {
     throw new Error(`Failed to parse config from ${absPath}: ${error}`);
@@ -185,6 +187,7 @@ async function loadPyConfig(absPath, logger) {
           emits: flowCfg.emits,
           subscribes,
           triggers: flowCfg.triggers,
+          stepTimeout: flowCfg.stepTimeout,
           awaitBefore: flowCfg.awaitBefore,
           awaitAfter: flowCfg.awaitAfter
         };
@@ -334,6 +337,7 @@ function buildFlows(flowSources) {
             queue,
             workerId: id,
             emits: f.emits,
+            stepTimeout: f.stepTimeout,
             awaitBefore: f.awaitBefore,
             awaitAfter: f.awaitAfter
           };
@@ -347,6 +351,7 @@ function buildFlows(flowSources) {
             workerId: id,
             subscribes: f.subscribes,
             emits: f.emits,
+            stepTimeout: f.stepTimeout,
             awaitBefore: f.awaitBefore,
             awaitAfter: f.awaitAfter
           };
@@ -361,6 +366,7 @@ function buildFlows(flowSources) {
             workerId: id,
             subscribes: f.subscribes,
             emits: f.emits,
+            stepTimeout: f.stepTimeout,
             awaitBefore: f.awaitBefore,
             awaitAfter: f.awaitAfter
           };
@@ -407,10 +413,10 @@ function parseSubscription(token) {
   }
   return { type: "implicit", value: token };
 }
-function findEmitter(token, entryStep, steps) {
+function findEmitter(token, entryStep, steps, entry) {
   const { type, value } = parseSubscription(token);
-  if (entryStep) {
-    const entryEmits = steps[entryStep]?.emits || [];
+  if (entryStep && entry) {
+    const entryEmits = entry.emits || [];
     if (entryEmits.includes(token) || entryEmits.includes(value)) {
       return entryStep;
     }
@@ -439,13 +445,13 @@ function findEmitter(token, entryStep, steps) {
   }
   return null;
 }
-function buildDependencyGraph(entryStep, steps) {
+function buildDependencyGraph(entryStep, steps, entry) {
   const dependencies = {};
   for (const [stepName, step] of Object.entries(steps)) {
     const deps = /* @__PURE__ */ new Set();
     const subscribes = step.subscribes || [];
     for (const token of subscribes) {
-      const emitter = findEmitter(token, entryStep, steps);
+      const emitter = findEmitter(token, entryStep, steps, entry);
       if (emitter && emitter !== stepName) {
         deps.add(emitter);
       }
@@ -520,27 +526,67 @@ function findTriggeredSteps(stepName, step, allSteps) {
   }
   return Array.from(triggered);
 }
+function getAwaitDefaultTimeout(awaitConfig) {
+  if (!awaitConfig) return 0;
+  if (awaitConfig.timeout && awaitConfig.timeout > 0) {
+    return awaitConfig.timeout;
+  }
+  const type = awaitConfig.type;
+  switch (type) {
+    case "webhook":
+      return 24 * 60 * 60 * 1e3;
+    // 24 hours (matches flow.awaitDefaults.webhookTimeout)
+    case "event":
+      return 24 * 60 * 60 * 1e3;
+    // 24 hours (matches flow.awaitDefaults.eventTimeout)
+    case "time":
+      return 0;
+    // No timeout for time awaits by default
+    case "schedule":
+      return 0;
+    // No timeout for schedule awaits by default
+    default:
+      return 0;
+  }
+}
 function getStepAwaitTimeout(step) {
   let timeout = 0;
-  if (step.awaitBefore?.timeout) timeout += step.awaitBefore.timeout;
-  if (step.awaitAfter?.timeout) timeout += step.awaitAfter.timeout;
+  if (step.awaitBefore) {
+    timeout += getAwaitDefaultTimeout(step.awaitBefore);
+  }
+  if (step.awaitAfter) {
+    timeout += getAwaitDefaultTimeout(step.awaitAfter);
+  }
   return timeout;
 }
+function getStepExecutionTimeout(step, config) {
+  if (step.stepTimeout !== void 0) {
+    return step.stepTimeout;
+  }
+  if (config?.flow?.stepTimeout !== void 0) {
+    return config.flow.stepTimeout;
+  }
+  if (config?.queue?.defaultJobOptions?.timeout !== void 0) {
+    return config.queue.defaultJobOptions.timeout;
+  }
+  return void 0;
+}
 function calculateFlowStallTimeout(steps, levels) {
   const DEFAULT_STALL_TIMEOUT = 30 * 60 * 1e3;
   const MIN_BUFFER = 5 * 60 * 1e3;
   const BUFFER_PERCENTAGE = 0.1;
+  const DEFAULT_STEP_TIMEOUT = 5 * 60 * 1e3;
   const levelTimeouts = [];
-  let awaitCount = 0;
   for (const levelSteps of levels) {
     let maxLevelTimeout = 0;
     for (const stepName of levelSteps) {
       const step = steps[stepName];
       if (!step) continue;
-      const stepTimeout = getStepAwaitTimeout(step);
-      if (stepTimeout > 0) {
-        awaitCount++;
-        maxLevelTimeout = Math.max(maxLevelTimeout, stepTimeout);
+      const stepExecTimeout = step.stepTimeout ?? DEFAULT_STEP_TIMEOUT;
+      const awaitTimeout = getStepAwaitTimeout(step);
+      const totalStepTimeout = stepExecTimeout + awaitTimeout;
+      if (totalStepTimeout > 0) {
+        maxLevelTimeout = Math.max(maxLevelTimeout, totalStepTimeout);
       }
     }
     if (maxLevelTimeout > 0) {
@@ -555,31 +601,57 @@ function calculateFlowStallTimeout(steps, levels) {
   const calculatedTimeout = totalAwaitTimeout + buffer;
   if (calculatedTimeout > DEFAULT_STALL_TIMEOUT * 2) {
     console.log(
-      `[flow-analyzer] Flow has ${awaitCount} await patterns across ${levelTimeouts.length} levels, calculated stall timeout: ${calculatedTimeout / 1e3}s (total await time: ${totalAwaitTimeout / 1e3}s, level timeouts: [${levelTimeouts.map((t) => `${t / 1e3}s`).join(", ")}])`
+      `[flow-analyzer] Flow stall timeout calculated across ${levelTimeouts.length} levels: ${calculatedTimeout / 1e3}s (total time: ${totalAwaitTimeout / 1e3}s, level timeouts: [${levelTimeouts.map((t) => `${t / 1e3}s`).join(", ")}])`
     );
   }
   return calculatedTimeout;
 }
-function analyzeFlow(flow) {
+function analyzeFlow(flow, config) {
   const entryStepName = flow.entry?.step;
   const steps = flow.steps || {};
-  const dependencies = buildDependencyGraph(entryStepName, steps);
+  const dependencies = buildDependencyGraph(entryStepName, steps, flow.entry);
   const levels = calculateLevels(entryStepName, dependencies);
   const analyzedSteps = {};
+  if (flow.entry && entryStepName) {
+    const hasAwaitPattern = !!(flow.entry.awaitBefore || flow.entry.awaitAfter);
+    const entryStep = {
+      queue: flow.entry.queue,
+      workerId: flow.entry.workerId,
+      emits: flow.entry.emits,
+      stepTimeout: flow.entry.stepTimeout,
+      // Include stepTimeout from flow metadata
+      awaitBefore: flow.entry.awaitBefore,
+      awaitAfter: flow.entry.awaitAfter,
+      name: entryStepName,
+      dependsOn: [],
+      triggers: findTriggeredSteps(entryStepName, flow.entry, steps),
+      level: 0,
+      hasAwaitPattern
+    };
+    entryStep.stepTimeout = getStepExecutionTimeout(entryStep, config);
+    analyzedSteps[entryStepName] = entryStep;
+  }
   for (const [stepName, step] of Object.entries(steps)) {
     const hasAwaitPattern = !!(step.awaitBefore || step.awaitAfter);
-    analyzedSteps[stepName] = {
+    const analyzedStep = {
       ...step,
       name: stepName,
       dependsOn: dependencies[stepName] || [],
       triggers: findTriggeredSteps(stepName, step, steps),
       level: levels[stepName] ?? 1,
       hasAwaitPattern
+      // stepTimeout from ...step spread above (per-function config)
     };
+    analyzedStep.stepTimeout = getStepExecutionTimeout(analyzedStep, config);
+    analyzedSteps[stepName] = analyzedStep;
   }
   const maxLevel = Math.max(0, ...Object.values(levels));
   const levelGroups = Array.from({ length: maxLevel + 1 }, () => []);
+  if (entryStepName && flow.entry) {
+    levelGroups[0]?.push(entryStepName);
+  }
   for (const [stepName, level] of Object.entries(levels)) {
+    if (stepName === entryStepName) continue;
     const levelArray = levelGroups[level];
     if (levelArray) {
       levelArray.push(stepName);
@@ -822,7 +894,7 @@ function generateAnalyzedFlowsTemplate(registry) {
       entry,
       steps
     };
-    const analyzed = analyzeFlow(flowMeta);
+    const analyzed = analyzeFlow(flowMeta, registry.config);
     return {
       ...flowMeta,
       analyzed: {
@@ -909,6 +981,25 @@ export type {
   ListOptions,
 } from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/store"))}
 
+// Flow Types
+export type {
+  FlowStats,
+  StartFlowResult,
+  CancelFlowResult,
+  RunningFlow,
+  FlowComposable,
+} from ${JSON.stringify(resolverFn("./runtime/nitro/utils/useFlow"))}
+
+// Runner Context Types
+export type {
+  QueueJob,
+  RunLogger,
+  RunState,
+  RunContextFlow,
+  RunContext,
+  NodeHandler,
+} from ${JSON.stringify(resolverFn("./runtime/worker/node/runner"))}
+
 // Event Types
 export type {
   EventType,
@@ -998,6 +1089,10 @@ function getServerImports(resolverFn, buildDir) {
       name: "defineAwaitResolveHook",
       from: resolverFn("./runtime/nitro/utils/defineHooks")
     },
+    {
+      name: "defineAwaitTimeoutHook",
+      from: resolverFn("./runtime/nitro/utils/defineHooks")
+    },
     // Adapter composables
     {
       name: "useQueueAdapter",
@@ -1070,9 +1165,10 @@ function getServerImports(resolverFn, buildDir) {
   ];
 }
 
+const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 const meta = {
   name: "nvent",
-  version: "0.4.1",
+  version: packageJson.version,
   configKey: "nvent"
 };
 const module$1 = defineNuxtModule().with({
@@ -1117,7 +1213,11 @@ const module$1 = defineNuxtModule().with({
       logger: { name: "console", level: "info" },
       runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
       flows: {},
-      eventIndex: {}
+      eventIndex: {},
+      config: {
+        flow: config.flow,
+        queue: config.queue
+      }
     });
     const compiledSnapshot = JSON.parse(JSON.stringify(compiledWithMeta));
     let lastCompiledRegistry = compiledSnapshot;
@@ -1177,7 +1277,11 @@ const module$1 = defineNuxtModule().with({
         logger: { name: "console", level: "info" },
         runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
         flows: {},
-        eventIndex: {}
+        eventIndex: {},
+        config: {
+          flow: config.flow,
+          queue: config.queue
+        }
       })));
       console.log(`[nvent] registry refreshed (${reason})`, changedPath || "");
       console.log(`[nvent] new registry has ${lastCompiledRegistry.workers?.length || 0} workers`);

package/dist/runtime/adapters/builtin/memory-store.d.ts

@@ -43,6 +43,7 @@ export declare class MemoryStoreAdapter implements StoreAdapter {
         read: (key: string, opts?: {
             offset?: number;
             limit?: number;
+            filter?: Record<string, any>;
         }) => Promise<Array<{
             id: string;
             score: number;
@@ -61,7 +62,7 @@ export declare class MemoryStoreAdapter implements StoreAdapter {
     /**
      * Convert dot notation keys to nested objects
      * e.g., { 'stats.totalFires': 5 } -> { stats: { totalFires: 5 } }
-     * null values are preserved for deletion
+     * null values are tracked for deletion after merge
      */
     private expandDotNotation;
     private generateId;

package/dist/runtime/adapters/builtin/memory-store.js

@@ -173,7 +173,19 @@ export class MemoryStoreAdapter {
       return entry ? { ...entry } : null;
     },
     read: async (key, opts) => {
-      const index = this.sortedIndices.get(key) || [];
+      let index = this.sortedIndices.get(key) || [];
+      if (opts?.filter) {
+        index = index.filter((entry) => {
+          for (const [field, value] of Object.entries(opts.filter)) {
+            if (Array.isArray(value)) {
+              if (!value.includes(entry.metadata?.[field])) return false;
+            } else if (entry.metadata?.[field] !== value) {
+              return false;
+            }
+          }
+          return true;
+        });
+      }
       const offset = opts?.offset || 0;
       const limit = opts?.limit || 50;
       return index.slice(offset, offset + limit).map((e) => ({ ...e }));
@@ -291,9 +303,9 @@ export class MemoryStoreAdapter {
   /**
    * Convert dot notation keys to nested objects
    * e.g., { 'stats.totalFires': 5 } -> { stats: { totalFires: 5 } }
-   * null values are preserved for deletion
+   * null values are tracked for deletion after merge
    */
-  expandDotNotation(obj) {
+  expandDotNotation(obj, parentPath = []) {
     const result = {};
     const deleteMarkers = [];
     for (const [key, value] of Object.entries(obj)) {
@@ -303,7 +315,7 @@ export class MemoryStoreAdapter {
       if (key.includes(".")) {
         const keys = key.split(".");
         if (value === null || value === void 0) {
-          deleteMarkers.push({ path: keys, delete: true });
+          deleteMarkers.push({ path: [...parentPath, ...keys], delete: true });
           continue;
         }
         let current = result;
@@ -315,6 +327,18 @@ export class MemoryStoreAdapter {
           current = current[k];
         }
         current[keys[keys.length - 1]] = value;
+      } else if (value === null || value === void 0) {
+        deleteMarkers.push({ path: [...parentPath, key], delete: true });
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const nested = this.expandDotNotation(value, [...parentPath, key]);
+        const nestedDeleteMarkers = nested.__deleteMarkers;
+        delete nested.__deleteMarkers;
+        if (nestedDeleteMarkers) {
+          deleteMarkers.push(...nestedDeleteMarkers);
+        }
+        if (Object.keys(nested).length > 0) {
+          result[key] = nested;
+        }
       } else {
         result[key] = value;
       }

package/dist/runtime/adapters/factory.js

@@ -69,13 +69,14 @@ async function createStoreAdapter(config) {
   try {
     const { StoreSubjects } = useStreamTopics();
     const flowIndexKey = StoreSubjects.flowIndex();
-    const existingFlows = await adapter.index.read(flowIndexKey, { limit: 1 });
-    if (existingFlows.length === 0) {
-      const analyzedFlows = $useAnalyzedFlows();
-      if (analyzedFlows && analyzedFlows.length > 0) {
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        for (const flow of analyzedFlows) {
-          await adapter.index.add(flowIndexKey, flow.id, Date.now(), {
+    const analyzedFlows = $useAnalyzedFlows();
+    if (analyzedFlows && analyzedFlows.length > 0) {
+      const existingFlows = await adapter.index.read(flowIndexKey, { limit: 100 });
+      const existingFlowIds = new Set(existingFlows.map((f) => f.id));
+      const now = Date.now();
+      for (const flow of analyzedFlows) {
+        if (!existingFlowIds.has(flow.id)) {
+          await adapter.index.add(flowIndexKey, flow.id, now, {
             name: flow.id,
             displayName: flow.id,
             registeredAt: now,

package/dist/runtime/adapters/interfaces/queue.d.ts

@@ -49,6 +49,11 @@ export interface QueueAdapter {
      * @returns true if removed, false if not found
      */
     removeScheduledJob?(scheduleId: string): Promise<boolean>;
+    /**
+     * Remove/cancel a job by ID
+     * @returns true if removed, false if not found
+     */
+    removeJob?(queueName: string, jobId: string): Promise<boolean>;
     /**
      * Pause the queue
      */

package/dist/runtime/adapters/interfaces/store.d.ts

@@ -167,14 +167,16 @@ export interface StoreAdapter {
         /**
          * Read entries from a sorted index (ordered by score descending)
          * @param key - Index key
-         * @param opts - Pagination options
+         * @param opts - Pagination and filter options
          * @param opts.offset - Number of entries to skip
          * @param opts.limit - Maximum number of entries to return
+         * @param opts.filter - Optional filter criteria for metadata fields (adapter-dependent efficiency)
          * @returns Array of entries with scores and metadata
          */
         read(key: string, opts?: {
             offset?: number;
             limit?: number;
+            filter?: Record<string, any>;
         }): Promise<Array<{
             id: string;
             score: number;

package/dist/runtime/config/index.js

@@ -45,7 +45,20 @@ export function normalizeModuleOptions(options) {
         checkInterval: 15 * 60 * 1e3,
         // 15 minutes
         enablePeriodicCheck: true
-      }
+      },
+      awaitDefaults: {
+        webhookTimeout: 24 * 60 * 60 * 1e3,
+        // 24 hours
+        eventTimeout: 24 * 60 * 60 * 1e3,
+        // 24 hours
+        timeTimeout: void 0,
+        // No default timeout for time awaits
+        scheduleTimeout: void 0,
+        // No default timeout for schedule awaits
+        timeoutAction: "fail"
+      },
+      stepTimeout: 5 * 60 * 1e3
+      // 5 minutes default step execution timeout
     },
     webhooks: {
       // baseUrl will be determined at runtime from Nitro context

package/dist/runtime/config/types.d.ts

@@ -238,6 +238,48 @@ export interface FlowConfig {
          */
         enablePeriodicCheck?: boolean;
     };
+    /**
+     * Default timeout values for await patterns
+     * These are used when developers don't specify explicit timeouts
+     * @since v0.5.0
+     */
+    awaitDefaults?: {
+        /**
+         * Default timeout for webhook await patterns in milliseconds
+         * @default 86400000 (24 hours)
+         */
+        webhookTimeout?: number;
+        /**
+         * Default timeout for event await patterns in milliseconds
+         * @default 86400000 (24 hours)
+         */
+        eventTimeout?: number;
+        /**
+         * Default timeout for time await patterns in milliseconds
+         * Time awaits typically don't need a timeout since they resolve based on delay
+         * @default undefined (no timeout)
+         */
+        timeTimeout?: number;
+        /**
+         * Default timeout for schedule await patterns in milliseconds
+         * Schedule awaits typically don't need a timeout since they resolve based on cron
+         * @default undefined (no timeout)
+         */
+        scheduleTimeout?: number;
+        /**
+         * Default timeout action when await times out
+         * @default 'fail'
+         */
+        timeoutAction?: 'fail' | 'continue' | 'retry';
+    };
+    /**
+     * Default step execution timeout in milliseconds
+     * This is the maximum time a step function can run before timing out
+     * Priority: defineFunctionConfig > flow.stepTimeout > queue.defaultJobOptions.timeout
+     * @default 300000 (5 minutes)
+     * @since v0.5.0
+     */
+    stepTimeout?: number;
 }
 /**
  * State management configuration

package/dist/runtime/events/types.d.ts

@@ -57,7 +57,6 @@ export interface FlowStalledEvent extends BaseEvent {
     type: 'flow.stalled';
     data?: {
         lastActivityAt?: number;
-        stallTimeout?: number;
     };
 }
 export interface StepStartedEvent extends StepEvent {

package/dist/runtime/events/utils/stallDetector.d.ts

@@ -2,102 +2,45 @@
  * Flow Stall Detection System
  *
  * Detects and marks flows that have been in "running" state for too long without activity.
- * Uses a hybrid approach:
- * 1. Lazy detection: Check stall status when flows are queried (zero overhead)
- * 2. Periodic cleanup: Background job that checks all running flows periodically (safety net)
+ * Uses per-flow scheduler jobs for precise timeout tracking:
  *
- * A flow is considered "stalled" when:
- * - Status is "running"
- * - No activity (step events) for longer than STALL_TIMEOUT
- * - lastActivityAt timestamp is older than threshold
+ * - On flow.start: Schedule timeout job with flow-specific deadline
+ * - On step events: Reschedule to extend timeout from current time
+ * - On flow end: Unschedule the timeout job
+ * - When timeout fires: Mark flow as stalled
+ *
+ * Startup recovery handles flows left running from previous server instance.
  */
 import type { StoreAdapter } from '../../adapters/interfaces/store.js';
 export interface StallDetectorConfig {
     /**
-     * Time in milliseconds after which a running flow without activity is considered stalled
-     * @default 1800000 (30 minutes)
-     */
-    stallTimeout?: number;
-    /**
-     * Interval in milliseconds for periodic stall checks
-     * @default 900000 (15 minutes)
-     */
-    checkInterval?: number;
-    /**
-     * Enable periodic background checks
-     * Set to false to use only lazy detection
+     * Enable stall detection system
      * @default true
      */
-    enablePeriodicCheck?: boolean;
+    enabled?: boolean;
 }
 export type FlowStatus = 'running' | 'completed' | 'failed' | 'canceled' | 'stalled';
-export interface FlowActivity {
-    runId: string;
-    flowName: string;
-    status: FlowStatus;
-    startedAt: number;
-    lastActivityAt: number;
-    metadata?: any;
-}
 export declare class FlowStallDetector {
     private store;
     private config;
     private logger;
-    private schedulerJobId?;
     private started;
     constructor(store: StoreAdapter, config?: StallDetectorConfig);
     /**
-     * Start the periodic stall detector
-     * Should be called once per instance after adapters are initialized
+     * Start the stall detector
      * Runs startup recovery to clean up flows from previous server instances
+     * Note: Periodic checking removed - now uses per-flow scheduler jobs
      */
     start(): Promise<void>;
     /**
-     * Get the configuration for scheduling
-     * Returns config needed by flowWiring to register the scheduler job
-     */
-    getScheduleConfig(): {
-        enabled: boolean;
-        interval: number;
-        stallTimeout: number;
-    };
-    /**
-     * Set the scheduler job ID (called from flowWiring after scheduling)
-     */
-    setSchedulerJobId(jobId: string): void;
-    /**
-     * Stop the periodic stall detector
+     * Stop the stall detector
      */
     stop(): Promise<void>;
-    /**
-     * Get stall timeout for a specific flow
-     * Uses flow-specific timeout from analyzed metadata, falls back to global config
-     */
-    private getFlowStallTimeout;
-    /**
-     * Update activity timestamp for a flow
-     * Should be called on every step event (started, completed, failed, retry)
-     */
-    updateActivity(flowName: string, runId: string): Promise<void>;
-    /**
-     * Check if a specific flow is stalled (lazy detection)
-     * Returns true if the flow should be marked as stalled
-     * v0.5: Await-aware - uses flow-specific timeout and skips awaiting flows
-     */
-    isStalled(flowName: string, runId: string): Promise<boolean>;
     /**
      * Mark a flow as stalled
      * Emits a flow.stalled event and updates the flow status
      */
     markAsStalled(flowName: string, runId: string, reason?: string): Promise<void>;
-    /**
-     * Check all running flows and mark stalled ones
-     * This is called by the periodic background job
-     *
-     * Note: This method requires knowledge of which flows exist.
-     * For now, we'll need to pass flow names to check, or iterate known flows from registry.
-     */
-    checkFlowsForStalls(flowNames: string[]): Promise<void>;
     /**
      * Run startup recovery to clean up flows left in running state from previous server instance
      * This marks all running flows as stalled since their in-memory state is lost
@@ -119,19 +62,12 @@ export declare class FlowStallDetector {
      * - Minor discrepancies don't affect runtime behavior
      */
     private validateFlowStats;
-    /**
-     * Internal method for periodic checks
-     * Gets flow names from registry and checks them
-     */
-    private checkAllRunningFlows;
     /**
      * Get stall detector statistics
      */
     getStats(): {
         enabled: boolean;
-        periodicCheckEnabled: boolean;
-        stallTimeout: number;
-        checkInterval: number;
+        mode: string;
     };
 }
 /**