@lostgradient/weft 0.5.0 → 0.6.0

package/dist/core/engine/construction.d.ts

@@ -19,6 +19,7 @@ export type EngineCreateRuntimeOptions = EngineConstructorOptions & {
     workflows?: Record<string, AnyWorkflowDefinition> | undefined;
     recover?: boolean | undefined;
     acknowledgeUnknownWorkflowTypes?: boolean | undefined;
+    startScheduler?: boolean | undefined;
 };
 export type NormalizedWorkerExecutionConfiguration = {
     mode: 'inline';

package/dist/core/engine/engine-create-types.d.ts

@@ -29,6 +29,20 @@ export type EngineCreateOptions<TWorkflowDefinitions extends Record<string, AnyW
     workflows?: TWorkflowDefinitions;
     /** Activity definitions to register before workflows. */
     activities?: TActivityDefinitions;
+    /**
+     * Start the scheduler's durable-timer polling loop after registration so
+     * `ctx.sleep(...)` and `engine.schedule(...)` timers fire in a long-lived
+     * in-process host. This is independent of `recover`: it controls *whether
+     * timers fire*, not *who drives `recoverAll`*.
+     *
+     * Defaults to `recover !== false`. A host that opts out of auto-recovery
+     * with `recover: false` (because it drives its own `recoverAll()` to capture
+     * the recovered handles) can still arm the poller by passing
+     * `startScheduler: true`. Pass `startScheduler: false` to keep the poller
+     * stopped even when recovery runs (tests / `ScopedStorage` engines that tick
+     * the scheduler deterministically).
+     */
+    startScheduler?: boolean;
 } & ({
     /**
      * Recover stored running workflows after registration. Defaults to

package/dist/core/engine/index.js

@@ -226,10 +226,10 @@ export class Engine extends EventTarget {
         engine.register(definition);
       }
       await engine.#acquireLeaseIfConfigured();
-      if (options.recover !== !1) {
+      if (options.recover !== !1)
         await engine.recoverAll(options.acknowledgeUnknownWorkflowTypes !== void 0 ? { acknowledgeUnknownWorkflowTypes: options.acknowledgeUnknownWorkflowTypes } : {});
+      if (options.startScheduler ?? options.recover !== !1)
         getInternals(engine).scheduler.start();
-      }
     } catch (error) {
       await engine[Symbol.asyncDispose]();
       throw error;