@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-DM7C5NP5.js

@@ -0,0 +1,819 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  compileWorkflowRuntimeStepsV1,
+  evalInputExpr,
+  makeWorkflowError
+} from "./chunk-UZZBHWIO.js";
+import {
+  attachLogicUnitMeta,
+  currentTxnOriginOverride
+} from "./chunk-BJOWSSEL.js";
+import {
+  RootContextTag
+} from "./chunk-UBMUY7WO.js";
+import {
+  getRuntimeInternals
+} from "./chunk-7GPAF2UK.js";
+import {
+  HostSchedulerTag,
+  TickSchedulerTag,
+  forceSourceRefresh,
+  inSyncTransactionFiber
+} from "./chunk-YMVMZA3U.js";
+import {
+  makeInRunSession,
+  run
+} from "./chunk-W365QUZ5.js";
+import {
+  currentDiagnosticsLevel,
+  record,
+  toSerializableErrorSummary
+} from "./chunk-SH7TP5CJ.js";
+import {
+  EffectOpMiddlewareTag
+} from "./chunk-SI5OKFFY.js";
+
+// ../logix-core/src/internal/runtime/core/WorkflowRuntime.ts
+import { Cause, Context, Deferred, Effect, Exit, Fiber, FiberRef, Option, Stream } from "../effect.js";
+var WORKFLOW_REGISTRY = /* @__PURE__ */ Symbol.for("@logixjs/core/workflowRegistry");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isObjectLike = (value) => typeof value === "object" && value !== null || typeof value === "function";
+var getRegistry = (runtime) => runtime[WORKFLOW_REGISTRY];
+var resolveActionTag = (action) => {
+  const tag = isObjectLike(action) ? action._tag : void 0;
+  if (typeof tag === "string" && tag.length > 0) return tag;
+  const type = isObjectLike(action) ? action.type : void 0;
+  if (typeof type === "string" && type.length > 0) return type;
+  if (tag != null) return String(tag);
+  if (type != null) return String(type);
+  return void 0;
+};
+var asNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var KERNEL_PORT_SOURCE_REFRESH = "logix/kernel/sourceRefresh";
+var resolveServicePort = (runtime, env, serviceId, programId, stepKey) => {
+  if (serviceId === KERNEL_PORT_SOURCE_REFRESH) {
+    return (input) => Effect.gen(function* () {
+      const fieldPath = asNonEmptyString(isRecord(input) ? input.fieldPath : void 0);
+      if (!fieldPath) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_STEP",
+          message: "KernelPort sourceRefresh requires input.fieldPath (non-empty string).",
+          programId,
+          source: { stepKey },
+          detail: { serviceId, input }
+        });
+      }
+      const internals = getRuntimeInternals(runtime);
+      const handler = internals.traits.getSourceRefreshHandler(fieldPath);
+      if (!handler) {
+        return;
+      }
+      const force = isRecord(input) && input.force === true;
+      const runHandler = (state) => force ? Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
+      const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+      if (inTxn) {
+        const state = yield* runtime.getState;
+        yield* runHandler(state);
+        return;
+      }
+      yield* internals.txn.runWithStateTransaction(
+        {
+          kind: "source-refresh",
+          name: fieldPath
+        },
+        () => Effect.gen(function* () {
+          const state = yield* runtime.getState;
+          yield* runHandler(state);
+        })
+      );
+    });
+  }
+  const tag = Context.GenericTag(serviceId);
+  const opt = Context.getOption(env, tag);
+  if (Option.isNone(opt)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_MISSING_SERVICE",
+      message: `Missing service for serviceId="${serviceId}".`,
+      programId,
+      source: { stepKey },
+      detail: { serviceId }
+    });
+  }
+  const value = opt.value;
+  if (typeof value === "function") {
+    const fn = value;
+    return (input) => fn(input);
+  }
+  const callFn = isObjectLike(value) ? value.call : void 0;
+  if (typeof callFn === "function") {
+    const call = callFn;
+    return (input) => call.call(value, input);
+  }
+  throw makeWorkflowError({
+    code: "WORKFLOW_INVALID_SERVICE_PORT",
+    message: `Invalid service port for serviceId="${serviceId}" (expected a function or { call(input): Effect }).`,
+    programId,
+    source: { stepKey },
+    detail: { serviceId, portType: typeof value }
+  });
+};
+var compileSteps = (steps, resolvePort) => {
+  const visit = (step) => {
+    switch (step.kind) {
+      case "dispatch":
+        return {
+          kind: "dispatch",
+          key: step.key,
+          actionTag: step.actionTag,
+          ...step.payload ? { payload: step.payload } : null
+        };
+      case "delay":
+        return { kind: "delay", key: step.key, ms: step.ms };
+      case "call":
+        return {
+          kind: "call",
+          key: step.key,
+          serviceId: step.serviceId,
+          port: resolvePort(step.serviceId, step.key),
+          ...step.input ? { input: step.input } : null,
+          ...step.timeoutMs !== void 0 ? { timeoutMs: step.timeoutMs } : null,
+          ...step.retryTimes !== void 0 ? { retryTimes: step.retryTimes } : null,
+          onSuccess: step.onSuccess.map(visit),
+          onFailure: step.onFailure.map(visit)
+        };
+    }
+  };
+  return steps.map(visit);
+};
+var resolveConcurrency = (def) => def.policy?.concurrency ?? "parallel";
+var resolvePriority = (def) => def.policy?.priority ?? "urgent";
+var makeRunId = (instanceId, programId, runSeq) => `${instanceId}::wf:${programId}::r${runSeq}`;
+var runBoundary = (args) => Effect.gen(function* () {
+  const op = yield* makeInRunSession({
+    kind: args.kind,
+    name: args.name,
+    effect: args.effect,
+    payload: args.payload,
+    meta: args.meta
+  });
+  const stack = args.middleware?.stack ?? [];
+  return yield* run(op, stack);
+});
+var makeTimer = (args) => Effect.async((resume) => {
+  let fired = false;
+  const cancel = args.host.scheduleTimeout(args.ms, () => {
+    fired = true;
+    args.host.scheduleMicrotask(() => resume(Effect.void));
+  });
+  return Effect.sync(() => {
+    cancel();
+  }).pipe(Effect.zipRight(fired ? Effect.void : args.onCancel));
+});
+var ensureLimiterReady = (registry, runtime) => Effect.gen(function* () {
+  if (registry.parallelLimiter !== void 0) return;
+  const internals = getRuntimeInternals(runtime);
+  const policy = yield* internals.concurrency.resolveConcurrencyPolicy();
+  const limit = policy.concurrencyLimit;
+  if (limit === "unbounded") {
+    registry.parallelLimiter = null;
+    return;
+  }
+  const n = typeof limit === "number" && Number.isFinite(limit) && limit >= 1 ? Math.floor(limit) : 16;
+  registry.parallelLimiter = yield* Effect.makeSemaphore(n);
+});
+var withRootEnvIfAvailable = (eff) => Effect.gen(function* () {
+  const rootOpt = yield* Effect.serviceOption(RootContextTag);
+  if (Option.isNone(rootOpt)) {
+    return yield* eff;
+  }
+  const root = rootOpt.value;
+  const rootEnv = root.context ?? (yield* Deferred.await(root.ready));
+  const currentEnv = yield* Effect.context();
+  const mergedEnv = Context.merge(rootEnv, currentEnv);
+  return yield* Effect.provide(eff, mergedEnv);
+});
+var ensurePortsResolved = (registry, runtime) => Effect.gen(function* () {
+  const done = yield* Deferred.isDone(registry.portsReady);
+  if (done) {
+    yield* Deferred.await(registry.portsReady);
+    return;
+  }
+  if (registry.portsResolving) {
+    yield* Deferred.await(registry.portsReady);
+    return;
+  }
+  registry.portsResolving = true;
+  const env = yield* Effect.context();
+  yield* Effect.sync(() => {
+    const portCache = /* @__PURE__ */ new Map();
+    for (const entry of registry.entries) {
+      const program = entry.program;
+      if (program.steps) continue;
+      const resolvePort = (serviceId, stepKey) => {
+        const cached = portCache.get(serviceId);
+        if (cached) return cached;
+        const resolved = resolveServicePort(runtime, env, serviceId, program.programId, stepKey);
+        portCache.set(serviceId, resolved);
+        return resolved;
+      };
+      program.steps = compileSteps(program.compiledSteps, resolvePort);
+    }
+  }).pipe(
+    Effect.tap(() => Deferred.succeed(registry.portsReady, void 0)),
+    Effect.catchAllCause((cause) => Deferred.failCause(registry.portsReady, cause).pipe(Effect.zipRight(Effect.failCause(cause)))),
+    Effect.ensuring(
+      Effect.sync(() => {
+        registry.portsResolving = false;
+      })
+    )
+  );
+});
+var shouldObserveForRun = (diagnostics, runSeq) => {
+  if (diagnostics === "off") return false;
+  if (diagnostics === "sampled") {
+    return (runSeq & 15) === 0;
+  }
+  return true;
+};
+var startProgramRun = (args) => Effect.gen(function* () {
+  const { entry, runtime, registry } = args;
+  const { program, state } = entry;
+  const diagnostics = yield* FiberRef.get(currentDiagnosticsLevel);
+  const beginRun = () => {
+    if (state.mode === "latest") {
+      state.runSeq += 1;
+      const runSeq3 = state.runSeq;
+      const runId3 = makeRunId(runtime.instanceId, program.programId, runSeq3);
+      return {
+        runSeq: runSeq3,
+        runId: runId3,
+        canWriteBack: () => state.runSeq === runSeq3
+      };
+    }
+    state.runSeq += 1;
+    const runSeq2 = state.runSeq;
+    const runId2 = makeRunId(runtime.instanceId, program.programId, runSeq2);
+    return {
+      runSeq: runSeq2,
+      runId: runId2,
+      canWriteBack: () => true
+    };
+  };
+  if (state.mode === "exhaust") {
+    if (state.busy) {
+      if (diagnostics !== "off") {
+        const observe2 = shouldObserveForRun(diagnostics, state.runSeq);
+        const tickSeq = observe2 ? (yield* TickSchedulerTag).getTickSeq() : void 0;
+        yield* runBoundary({
+          kind: "flow",
+          name: "workflow.drop",
+          payload: { programId: program.programId, trigger: args.trigger },
+          meta: {
+            moduleId: runtime.moduleId,
+            instanceId: runtime.instanceId,
+            programId: program.programId,
+            ...tickSeq !== void 0 ? { tickSeq } : null,
+            policy: { disableObservers: !observe2 },
+            reason: "exhaust"
+          },
+          effect: Effect.void,
+          middleware: args.middleware
+        });
+      }
+      return;
+    }
+    state.busy = true;
+  }
+  const { runSeq, runId, canWriteBack } = beginRun();
+  if (state.mode === "latest") {
+    const prev = state.current;
+    const prevRunId = state.currentRunId;
+    if (prev) {
+      yield* Fiber.interruptFork(prev);
+      if (diagnostics !== "off") {
+        const observe2 = shouldObserveForRun(diagnostics, runSeq);
+        const tickSeq = observe2 ? (yield* TickSchedulerTag).getTickSeq() : void 0;
+        yield* runBoundary({
+          kind: "flow",
+          name: "workflow.cancel",
+          payload: { programId: program.programId, cancelled: prevRunId, by: runId },
+          meta: {
+            moduleId: runtime.moduleId,
+            instanceId: runtime.instanceId,
+            programId: program.programId,
+            ...tickSeq !== void 0 ? { tickSeq } : null,
+            policy: { disableObservers: !observe2 },
+            reason: "latest",
+            cancelledByRunId: runId,
+            cancelledRunId: prevRunId
+          },
+          effect: Effect.void,
+          middleware: args.middleware
+        });
+      }
+    }
+    state.currentRunId = runId;
+  }
+  const observe = shouldObserveForRun(diagnostics, runSeq);
+  const policy = { disableObservers: !observe };
+  const programEffect = Effect.gen(function* () {
+    const host = yield* HostSchedulerTag;
+    const tick = yield* TickSchedulerTag;
+    if (!program.steps) {
+      const env = yield* Effect.context();
+      const portCache = /* @__PURE__ */ new Map();
+      const resolvePort = (serviceId, stepKey) => {
+        const cached = portCache.get(serviceId);
+        if (cached) return cached;
+        const resolved = resolveServicePort(runtime, env, serviceId, program.programId, stepKey);
+        portCache.set(serviceId, resolved);
+        return resolved;
+      };
+      program.steps = compileSteps(program.compiledSteps, resolvePort);
+    }
+    const getTickSeq = () => observe ? tick.getTickSeq() : void 0;
+    const emitTimerEvents = observe && diagnostics === "full";
+    const evalPayload = (expr) => expr ? evalInputExpr(expr, args.payload) : void 0;
+    const defaultInputForCall = () => args.trigger.kind === "action" ? args.payload : void 0;
+    let timerTriggered = false;
+    const runSteps = (steps) => Effect.gen(function* () {
+      for (const step of steps) {
+        if (!canWriteBack()) return;
+        if (step.kind === "dispatch") {
+          const payload = evalPayload(step.payload);
+          const action = { _tag: step.actionTag, payload };
+          const tickSeq = getTickSeq();
+          const dispatchEffectBase = program.priority === "nonUrgent" ? runtime.dispatchLowPriority(action) : runtime.dispatch(action);
+          const dispatchEffect = timerTriggered ? Effect.locally(
+            currentTxnOriginOverride,
+            {
+              kind: "workflow.timer",
+              name: `timer:${program.programId}:${step.key}`
+            }
+          )(dispatchEffectBase) : dispatchEffectBase;
+          yield* runBoundary({
+            kind: "flow",
+            name: "workflow.dispatch",
+            payload: { actionTag: step.actionTag },
+            meta: {
+              moduleId: runtime.moduleId,
+              instanceId: runtime.instanceId,
+              programId: program.programId,
+              runId,
+              stepKey: step.key,
+              ...tickSeq !== void 0 ? { tickSeq } : null,
+              policy
+            },
+            effect: dispatchEffect,
+            middleware: args.middleware
+          }).pipe(Effect.asVoid);
+          continue;
+        }
+        if (step.kind === "delay") {
+          const timerId = emitTimerEvents ? `${runId}::timer:${step.key}` : void 0;
+          const recordTimerEvent = (name, patchMeta) => Effect.gen(function* () {
+            const tickSeq2 = getTickSeq();
+            yield* runBoundary({
+              kind: "flow",
+              name,
+              payload: { ms: step.ms },
+              meta: {
+                moduleId: runtime.moduleId,
+                instanceId: runtime.instanceId,
+                programId: program.programId,
+                runId,
+                stepKey: step.key,
+                ...timerId ? { timerId } : null,
+                ...tickSeq2 !== void 0 ? { tickSeq: tickSeq2 } : null,
+                policy,
+                ...patchMeta ?? null
+              },
+              effect: Effect.void,
+              middleware: args.middleware
+            });
+          });
+          const schedule = emitTimerEvents ? recordTimerEvent("workflow.timer.schedule") : Effect.void;
+          const onCancel = emitTimerEvents ? recordTimerEvent("workflow.timer.cancel", { reason: "interrupt" }) : Effect.void;
+          const fired = emitTimerEvents ? recordTimerEvent("workflow.timer.fired") : Effect.void;
+          const delayEffect = schedule.pipe(
+            Effect.zipRight(makeTimer({ host, ms: step.ms, onCancel })),
+            Effect.zipRight(fired)
+          );
+          const tickSeq = getTickSeq();
+          yield* runBoundary({
+            kind: "flow",
+            name: "workflow.delay",
+            payload: { ms: step.ms },
+            meta: {
+              moduleId: runtime.moduleId,
+              instanceId: runtime.instanceId,
+              programId: program.programId,
+              runId,
+              stepKey: step.key,
+              ...tickSeq !== void 0 ? { tickSeq } : null,
+              ...timerId ? { timerId } : null,
+              policy
+            },
+            effect: delayEffect,
+            middleware: args.middleware
+          }).pipe(Effect.asVoid);
+          timerTriggered = true;
+          continue;
+        }
+        const input = step.input ? evalInputExpr(step.input, args.payload) : defaultInputForCall();
+        const maxRetries = step.retryTimes ?? 0;
+        let exit;
+        for (let attempt = 1; attempt <= maxRetries + 1; attempt += 1) {
+          const tickSeq = getTickSeq();
+          const base = runBoundary({
+            kind: "service",
+            name: `workflow.call:${step.serviceId}`,
+            payload: { serviceId: step.serviceId },
+            meta: {
+              moduleId: runtime.moduleId,
+              instanceId: runtime.instanceId,
+              programId: program.programId,
+              runId,
+              stepKey: step.key,
+              serviceId: step.serviceId,
+              attempt,
+              ...tickSeq !== void 0 ? { tickSeq } : null,
+              policy
+            },
+            effect: step.port(input),
+            middleware: args.middleware
+          });
+          const withTimeout = step.timeoutMs === void 0 ? base : Effect.gen(function* () {
+            const timeoutMs = step.timeoutMs;
+            if (timeoutMs === void 0) {
+              return yield* base;
+            }
+            const timerId = emitTimerEvents ? `${runId}::timeout:${step.key}:a${attempt}` : void 0;
+            const recordTimeoutEvent = (name, patchMeta) => Effect.gen(function* () {
+              const tickSeq2 = getTickSeq();
+              yield* runBoundary({
+                kind: "flow",
+                name,
+                payload: { ms: timeoutMs },
+                meta: {
+                  moduleId: runtime.moduleId,
+                  instanceId: runtime.instanceId,
+                  programId: program.programId,
+                  runId,
+                  stepKey: step.key,
+                  attempt,
+                  ...timerId ? { timerId } : null,
+                  ...tickSeq2 !== void 0 ? { tickSeq: tickSeq2 } : null,
+                  policy,
+                  ...patchMeta ?? null
+                },
+                effect: Effect.void,
+                middleware: args.middleware
+              });
+            });
+            const schedule = emitTimerEvents ? recordTimeoutEvent("workflow.timeout.schedule") : Effect.void;
+            const onCancel = emitTimerEvents ? recordTimeoutEvent("workflow.timeout.cancel", { reason: "interrupt" }) : Effect.void;
+            const fired = emitTimerEvents ? recordTimeoutEvent("workflow.timeout.fired") : Effect.void;
+            const timeoutError = makeWorkflowError({
+              code: "WORKFLOW_CALL_TIMEOUT",
+              message: `Workflow call timed out (serviceId="${step.serviceId}", timeoutMs=${timeoutMs}).`,
+              programId: program.programId,
+              source: { stepKey: step.key },
+              detail: { serviceId: step.serviceId, timeoutMs, attempt }
+            });
+            const timeoutFail = schedule.pipe(
+              Effect.zipRight(makeTimer({ host, ms: timeoutMs, onCancel })),
+              Effect.zipRight(fired),
+              Effect.zipRight(Effect.fail(timeoutError))
+            );
+            return yield* Effect.raceFirst(base, timeoutFail);
+          });
+          const attemptExit = yield* Effect.exit(withTimeout);
+          exit = attemptExit;
+          if (!canWriteBack() || Exit.isSuccess(attemptExit)) {
+            break;
+          }
+          if (Cause.isInterrupted(attemptExit.cause) || Option.isNone(Cause.failureOption(attemptExit.cause))) {
+            break;
+          }
+          if (attempt < maxRetries + 1) {
+            continue;
+          }
+          break;
+        }
+        if (!exit) {
+          exit = Exit.succeed(void 0);
+        }
+        if (!canWriteBack()) return;
+        if (Exit.isSuccess(exit)) {
+          yield* runSteps(step.onSuccess);
+        } else {
+          const failure = Option.getOrUndefined(Cause.failureOption(exit.cause));
+          const isTimeout = isObjectLike(failure) && failure._tag === "WorkflowError" && failure.code === "WORKFLOW_CALL_TIMEOUT";
+          if (isTimeout) timerTriggered = true;
+          yield* runSteps(step.onFailure);
+        }
+      }
+    });
+    const runTickSeq = getTickSeq();
+    yield* runBoundary({
+      kind: "flow",
+      name: "workflow.run",
+      payload: { trigger: args.trigger },
+      meta: {
+        moduleId: runtime.moduleId,
+        instanceId: runtime.instanceId,
+        programId: program.programId,
+        runId,
+        ...runTickSeq !== void 0 ? { tickSeq: runTickSeq } : null,
+        policy
+      },
+      effect: runSteps(program.steps),
+      middleware: args.middleware
+    }).pipe(Effect.asVoid);
+  });
+  const limited = registry.parallelLimiter ? registry.parallelLimiter.withPermits(1)(programEffect) : programEffect;
+  const fiber = yield* Effect.forkScoped(
+    limited.pipe(
+      Effect.catchAllCause((cause) => {
+        const { errorSummary, downgrade } = toSerializableErrorSummary(cause);
+        const downgradeHint = downgrade ? ` (downgrade=${downgrade})` : "";
+        return record({
+          type: "diagnostic",
+          moduleId: runtime.moduleId,
+          instanceId: runtime.instanceId,
+          code: "workflow::run_crashed",
+          severity: "error",
+          message: `Workflow run crashed for programId="${program.programId}" runId="${runId}".${downgradeHint}`,
+          hint: `${errorSummary.name ? `${errorSummary.name}: ` : ""}${errorSummary.message}`,
+          actionTag: args.trigger.kind === "action" ? args.trigger.actionTag : void 0,
+          kind: "workflow_run_crashed",
+          trigger: {
+            kind: "workflow",
+            name: "run",
+            details: {
+              programId: program.programId,
+              runId,
+              trigger: args.trigger
+            }
+          }
+        }).pipe(Effect.catchAllCause(() => Effect.void));
+      }),
+      Effect.ensuring(
+        Effect.sync(() => {
+          if (state.mode === "exhaust") {
+            state.busy = false;
+          }
+        })
+      )
+    )
+  );
+  if (state.mode === "latest") {
+    state.current = fiber;
+  }
+});
+var ensureRegistry = (runtime) => Effect.gen(function* () {
+  const existing = getRegistry(runtime);
+  if (existing) {
+    return {
+      moduleId: runtime.moduleId,
+      instanceId: runtime.instanceId,
+      registry: existing
+    };
+  }
+  const portsReady = yield* Deferred.make();
+  const next = {
+    byActionTag: /* @__PURE__ */ new Map(),
+    entries: [],
+    watcherStarted: false,
+    watcherStartCount: 0,
+    portsResolving: false,
+    portsReady,
+    parallelLimiter: void 0
+  };
+  Object.defineProperty(runtime, WORKFLOW_REGISTRY, {
+    value: next,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return { moduleId: runtime.moduleId, instanceId: runtime.instanceId, registry: next };
+});
+var registerPrograms = (args) => Effect.gen(function* () {
+  const runtime = yield* args.moduleTag;
+  const { moduleId, instanceId, registry } = yield* ensureRegistry(runtime);
+  if (registry.parallelLimiter === void 0) {
+    yield* ensureLimiterReady(registry, runtime);
+  }
+  const validateNoIoStepsForOnInit = (steps, programId) => {
+    const visit = (step) => {
+      if (step.kind === "call" || step.kind === "delay") {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_TRIGGER",
+          message: "Lifecycle onInit programs must not include call/delay (initRequired must stay sync-only; use onStart for IO/time).",
+          programId,
+          source: { stepKey: step.key },
+          detail: { kind: step.kind }
+        });
+      }
+    };
+    for (const s of steps) visit(s);
+  };
+  const programHasCall = (steps) => steps.some((s) => s.kind === "call");
+  const insertEntry = (actionTag, entry) => {
+    const prev = registry.byActionTag.get(actionTag);
+    registry.byActionTag.set(actionTag, prev ? [...prev, entry] : [entry]);
+  };
+  const internals = getRuntimeInternals(runtime);
+  for (const program of args.programs) {
+    const def = program.def;
+    const localId = asNonEmptyString(def.localId);
+    if (!localId) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: "Workflow.install: def.localId must be a non-empty string.",
+        detail: { localId: def.localId }
+      });
+    }
+    const programId = `${moduleId}.${localId}`;
+    const compiled = compileWorkflowRuntimeStepsV1({ def });
+    if (def.trigger.kind === "lifecycle" && def.trigger.phase === "onInit") {
+      validateNoIoStepsForOnInit(compiled, programId);
+    }
+    const compiledProgram = {
+      programId,
+      localId,
+      trigger: def.trigger,
+      concurrency: resolveConcurrency(def),
+      priority: resolvePriority(def),
+      compiledSteps: compiled
+    };
+    if (!programHasCall(compiled)) {
+      compiledProgram.steps = compileSteps(compiled, () => {
+        throw makeWorkflowError({
+          code: "WORKFLOW_MISSING_SERVICE",
+          message: "Internal error: unexpected call step while resolving call-less program.",
+          programId,
+          detail: { programId }
+        });
+      });
+    }
+    const state = compiledProgram.concurrency === "latest" ? { mode: "latest", runSeq: 0, current: void 0, currentRunId: void 0 } : compiledProgram.concurrency === "exhaust" ? { mode: "exhaust", runSeq: 0, busy: false } : { mode: "parallel", runSeq: 0 };
+    const entry = { program: compiledProgram, state };
+    registry.entries.push(entry);
+    if (def.trigger.kind === "action") {
+      insertEntry(def.trigger.actionTag, entry);
+    } else {
+      if (def.trigger.phase === "onStart") {
+        internals.lifecycle.registerStart(
+          withRootEnvIfAvailable(
+            Effect.gen(function* () {
+              const middlewareOpt = yield* Effect.serviceOption(EffectOpMiddlewareTag);
+              const middleware = Option.isSome(middlewareOpt) ? middlewareOpt.value : void 0;
+              yield* ensurePortsResolved(registry, runtime).pipe(Effect.orDie);
+              yield* startProgramRun({
+                entry,
+                runtime,
+                registry,
+                trigger: { kind: "lifecycle", phase: "onStart" },
+                payload: void 0,
+                middleware
+              });
+            })
+          ),
+          { name: `workflow:${localId}` }
+        );
+      } else {
+        internals.lifecycle.registerInitRequired(
+          Effect.gen(function* () {
+            const middlewareOpt = yield* Effect.serviceOption(EffectOpMiddlewareTag);
+            const middleware = Option.isSome(middlewareOpt) ? middlewareOpt.value : void 0;
+            yield* startProgramRun({
+              entry,
+              runtime,
+              registry,
+              trigger: { kind: "lifecycle", phase: "onInit" },
+              payload: void 0,
+              middleware
+            });
+          }),
+          { name: `workflow:${localId}` }
+        );
+      }
+    }
+  }
+  void instanceId;
+});
+var startWatcherIfNeeded = (args) => Effect.gen(function* () {
+  const runtime = yield* args.moduleTag;
+  const init = yield* ensureRegistry(runtime);
+  const registry = init.registry;
+  if (registry.watcherStarted) {
+    return;
+  }
+  registry.watcherStarted = true;
+  registry.watcherStartCount += 1;
+  const middlewareOpt = yield* Effect.serviceOption(EffectOpMiddlewareTag);
+  const middleware = Option.isSome(middlewareOpt) ? middlewareOpt.value : void 0;
+  const actions$ = runtime.actions$;
+  const portsExit = yield* Effect.exit(ensurePortsResolved(registry, runtime));
+  if (Exit.isFailure(portsExit)) {
+    const { errorSummary, downgrade } = toSerializableErrorSummary(portsExit.cause);
+    const downgradeHint = downgrade ? ` (downgrade=${downgrade})` : "";
+    yield* record({
+      type: "diagnostic",
+      moduleId: runtime.moduleId,
+      instanceId: runtime.instanceId,
+      code: "workflow::ports_resolution_failed",
+      severity: "error",
+      message: `Workflow ports resolution failed before starting watcher.${downgradeHint}`,
+      hint: `${errorSummary.name ? `${errorSummary.name}: ` : ""}${errorSummary.message}`,
+      kind: "workflow_ports_resolution_failed",
+      trigger: {
+        kind: "workflow",
+        name: "portsResolution",
+        details: {
+          entryLabel: args.entryLabel
+        }
+      }
+    });
+    return;
+  }
+  yield* Stream.runForEach(
+    actions$,
+    (action) => Effect.gen(function* () {
+      const actionTag = resolveActionTag(action);
+      if (!actionTag) return;
+      const entries = registry.byActionTag.get(actionTag);
+      if (!entries || entries.length === 0) return;
+      const payload = isRecord(action) ? action.payload : void 0;
+      yield* Effect.forEach(
+        entries,
+        (entry) => startProgramRun({
+          entry,
+          runtime,
+          registry,
+          trigger: { kind: "action", actionTag },
+          payload,
+          middleware
+        }),
+        { discard: true }
+      );
+    })
+  ).pipe(
+    Effect.catchAllCause((cause) => {
+      const { errorSummary, downgrade } = toSerializableErrorSummary(cause);
+      const downgradeHint = downgrade ? ` (downgrade=${downgrade})` : "";
+      return record({
+        type: "diagnostic",
+        moduleId: runtime.moduleId,
+        instanceId: runtime.instanceId,
+        code: "workflow::watcher_crashed",
+        severity: "error",
+        message: `Workflow watcher crashed.${downgradeHint}`,
+        hint: `${errorSummary.name ? `${errorSummary.name}: ` : ""}${errorSummary.message}`,
+        kind: "workflow_watcher_crashed",
+        trigger: {
+          kind: "workflow",
+          name: "watcher",
+          details: {
+            entryLabel: args.entryLabel
+          }
+        }
+      });
+    })
+  );
+  void args.entryLabel;
+});
+var mountAll = (args) => {
+  const plan = {
+    setup: registerPrograms({ moduleTag: args.moduleTag, programs: args.programs, entryLabel: "mountAll" }),
+    run: startWatcherIfNeeded({ moduleTag: args.moduleTag, entryLabel: "mountAll" })
+  };
+  attachLogicUnitMeta(plan, {
+    id: "__logix_internal:workflows",
+    kind: "internal",
+    name: "workflows"
+  });
+  return plan;
+};
+var installOne = (args) => {
+  const localId = asNonEmptyString(args.program.def.localId) ?? "unknown";
+  const plan = {
+    setup: registerPrograms({ moduleTag: args.moduleTag, programs: [args.program], entryLabel: `install:${localId}` }),
+    run: startWatcherIfNeeded({ moduleTag: args.moduleTag, entryLabel: `install:${localId}` })
+  };
+  attachLogicUnitMeta(plan, {
+    id: `workflow:${localId}`,
+    kind: "workflow",
+    name: localId
+  });
+  return plan;
+};
+
+export {
+  mountAll,
+  installOne
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/WorkflowRuntime.ts"],
  "sourcesContent": ["import { Cause, Context, Deferred, Effect, Exit, Fiber, FiberRef, Option, Stream } from 'effect'\nimport * as EffectOpCore from './EffectOpCore.js'\nimport * as Debug from './DebugSink.js'\nimport * as LogicUnitMeta from './LogicUnitMeta.js'\nimport { toSerializableErrorSummary } from './errorSummary.js'\nimport type { AnyModuleShape, LogicPlan, ModuleRuntime as PublicModuleRuntime } from './module.js'\nimport { HostSchedulerTag, TickSchedulerTag } from './env.js'\nimport { currentTxnOriginOverride } from './TxnOriginOverride.js'\nimport { getRuntimeInternals } from './runtimeInternalsAccessor.js'\nimport { RootContextTag, type RootContext } from './RootContext.js'\nimport * as TaskRunner from './TaskRunner.js'\nimport * as EffectOp from '../../effect-op.js'\nimport { makeWorkflowError } from '../../workflow/errors.js'\nimport { compileWorkflowRuntimeStepsV1, type CompiledWorkflowStep } from '../../workflow/compiler.js'\nimport { evalInputExpr, type CompiledInputExpr } from '../../workflow/inputExpr.js'\nimport type { WorkflowDefV1, WorkflowTriggerV1 } from '../../workflow/model.js'\n\ntype ModuleTag = Context.Tag<unknown, PublicModuleRuntime<unknown, unknown>>\n\nexport type WorkflowLike = {\n  readonly _tag?: 'Workflow'\n  readonly def: WorkflowDefV1\n  readonly validate?: () => void\n}\n\ntype ConcurrencyMode = 'latest' | 'exhaust' | 'parallel'\ntype Priority = 'urgent' | 'nonUrgent'\n\ntype ServicePort = (input: unknown) => Effect.Effect<unknown, unknown, unknown>\n\ntype CompiledRuntimeStep =\n  | { readonly kind: 'dispatch'; readonly key: string; readonly actionTag: string; readonly payload?: CompiledInputExpr }\n  | { readonly kind: 'delay'; readonly key: string; readonly ms: number }\n  | {\n      readonly kind: 'call'\n      readonly key: string\n      readonly serviceId: string\n      readonly input?: CompiledInputExpr\n      readonly timeoutMs?: number\n      readonly retryTimes?: number\n      readonly port: ServicePort\n      readonly onSuccess: ReadonlyArray<CompiledRuntimeStep>\n      readonly onFailure: ReadonlyArray<CompiledRuntimeStep>\n    }\n\ntype CompiledProgram = {\n  readonly programId: string\n  readonly localId: string\n  readonly trigger: WorkflowTriggerV1\n  readonly concurrency: ConcurrencyMode\n  readonly priority: Priority\n  readonly compiledSteps: ReadonlyArray<CompiledWorkflowStep>\n  steps?: ReadonlyArray<CompiledRuntimeStep>\n}\n\ntype ProgramState =\n  | { readonly mode: 'latest'; runSeq: number; current?: Fiber.RuntimeFiber<void, never>; currentRunId?: string }\n  | { readonly mode: 'exhaust'; runSeq: number; busy: boolean }\n  | { readonly mode: 'parallel'; runSeq: number }\n\ntype ProgramEntry = {\n  readonly program: CompiledProgram\n  readonly state: ProgramState\n}\n\ntype WorkflowRegistryV1 = {\n  readonly byActionTag: Map<string, ReadonlyArray<ProgramEntry>>\n  readonly entries: Array<ProgramEntry>\n  watcherStarted: boolean\n  watcherStartCount: number\n  portsResolving: boolean\n  portsReady: Deferred.Deferred<void, unknown>\n  parallelLimiter: Effect.Semaphore | null | undefined\n}\n\nconst WORKFLOW_REGISTRY = Symbol.for('@logixjs/core/workflowRegistry')\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nconst isObjectLike = (value: unknown): value is Record<string, unknown> | ((...args: never[]) => unknown) =>\n  (typeof value === 'object' && value !== null) || typeof value === 'function'\n\nconst getRegistry = (runtime: object): WorkflowRegistryV1 | undefined =>\n  (runtime as Record<PropertyKey, unknown>)[WORKFLOW_REGISTRY] as WorkflowRegistryV1 | undefined\n\nconst resolveActionTag = (action: unknown): string | undefined => {\n  const tag = isObjectLike(action) ? (action as Record<string, unknown>)._tag : undefined\n  if (typeof tag === 'string' && tag.length > 0) return tag\n  const type = isObjectLike(action) ? (action as Record<string, unknown>).type : undefined\n  if (typeof type === 'string' && type.length > 0) return type\n  if (tag != null) return String(tag)\n  if (type != null) return String(type)\n  return undefined\n}\n\nconst asNonEmptyString = (value: unknown): string | undefined =>\n  typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined\n\nconst KERNEL_PORT_SOURCE_REFRESH = 'logix/kernel/sourceRefresh'\n\nconst resolveServicePort = (\n  runtime: PublicModuleRuntime<unknown, unknown>,\n  env: Context.Context<unknown>,\n  serviceId: string,\n  programId: string,\n  stepKey: string,\n): ServicePort => {\n  if (serviceId === KERNEL_PORT_SOURCE_REFRESH) {\n    return (input) =>\n      Effect.gen(function* () {\n        const fieldPath = asNonEmptyString(isRecord(input) ? input.fieldPath : undefined)\n        if (!fieldPath) {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_STEP',\n            message: 'KernelPort sourceRefresh requires input.fieldPath (non-empty string).',\n            programId,\n            source: { stepKey },\n            detail: { serviceId, input },\n          })\n        }\n\n        const internals = getRuntimeInternals(runtime)\n        const handler = internals.traits.getSourceRefreshHandler(fieldPath)\n\n        // If no refresh handler is registered, treat it as a no-op (aligns with BoundApiRuntime behavior).\n        if (!handler) {\n          return\n        }\n\n        const force = isRecord(input) && input.force === true\n        const runHandler = (state: unknown) =>\n          force ? Effect.locally(TaskRunner.forceSourceRefresh, true)(handler(state)) : handler(state)\n\n        const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n        if (inTxn) {\n          const state = yield* runtime.getState\n          yield* runHandler(state)\n          return\n        }\n\n        yield* internals.txn.runWithStateTransaction(\n          {\n            kind: 'source-refresh',\n            name: fieldPath,\n          },\n          () =>\n            Effect.gen(function* () {\n              const state = yield* runtime.getState\n              yield* runHandler(state)\n            }),\n        )\n      })\n  }\n\n  const tag = Context.GenericTag<unknown>(serviceId)\n  const opt = Context.getOption(env, tag)\n  if (Option.isNone(opt)) {\n    throw makeWorkflowError({\n      code: 'WORKFLOW_MISSING_SERVICE',\n      message: `Missing service for serviceId=\"${serviceId}\".`,\n      programId,\n      source: { stepKey },\n      detail: { serviceId },\n    })\n  }\n\n  const value: unknown = opt.value\n  if (typeof value === 'function') {\n    const fn = value as (input: unknown) => Effect.Effect<unknown, unknown, unknown>\n    return (input) => fn(input)\n  }\n\n  const callFn = isObjectLike(value) ? (value as Record<string, unknown>).call : undefined\n  if (typeof callFn === 'function') {\n    const call = callFn as (this: unknown, input: unknown) => Effect.Effect<unknown, unknown, unknown>\n    return (input) => call.call(value, input)\n  }\n\n  throw makeWorkflowError({\n    code: 'WORKFLOW_INVALID_SERVICE_PORT',\n    message: `Invalid service port for serviceId=\"${serviceId}\" (expected a function or { call(input): Effect }).`,\n    programId,\n    source: { stepKey },\n    detail: { serviceId, portType: typeof value },\n  })\n}\n\nconst compileSteps = (steps: ReadonlyArray<CompiledWorkflowStep>, resolvePort: (serviceId: string, stepKey: string) => ServicePort) => {\n  const visit = (step: CompiledWorkflowStep): CompiledRuntimeStep => {\n    switch (step.kind) {\n      case 'dispatch':\n        return {\n          kind: 'dispatch',\n          key: step.key,\n          actionTag: step.actionTag,\n          ...(step.payload ? { payload: step.payload } : null),\n        }\n      case 'delay':\n        return { kind: 'delay', key: step.key, ms: step.ms }\n      case 'call':\n        return {\n          kind: 'call',\n          key: step.key,\n          serviceId: step.serviceId,\n          port: resolvePort(step.serviceId, step.key),\n          ...(step.input ? { input: step.input } : null),\n          ...(step.timeoutMs !== undefined ? { timeoutMs: step.timeoutMs } : null),\n          ...(step.retryTimes !== undefined ? { retryTimes: step.retryTimes } : null),\n          onSuccess: step.onSuccess.map(visit),\n          onFailure: step.onFailure.map(visit),\n        }\n    }\n  }\n\n  return steps.map(visit)\n}\n\nconst resolveConcurrency = (def: WorkflowDefV1): ConcurrencyMode => (def.policy?.concurrency ?? 'parallel') as ConcurrencyMode\nconst resolvePriority = (def: WorkflowDefV1): Priority => (def.policy?.priority ?? 'urgent') as Priority\n\nconst makeRunId = (instanceId: string, programId: string, runSeq: number): string =>\n  `${instanceId}::wf:${programId}::r${runSeq}`\n\nconst runBoundary = <A, E, R>(args: {\n  readonly kind: EffectOp.EffectOp['kind']\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp.EffectOp['meta']\n  readonly middleware: EffectOpCore.EffectOpMiddlewareEnv | undefined\n}): Effect.Effect<A, E, R> =>\n  Effect.gen(function* () {\n    const op = yield* EffectOp.makeInRunSession({\n      kind: args.kind,\n      name: args.name,\n      effect: args.effect,\n      payload: args.payload,\n      meta: args.meta,\n    })\n    const stack = args.middleware?.stack ?? []\n    return yield* EffectOp.run(op, stack)\n  }) as unknown as Effect.Effect<A, E, R>\n\nconst makeTimer = (args: {\n  readonly host: {\n    readonly scheduleMicrotask: (cb: () => void) => void\n    readonly scheduleTimeout: (ms: number, cb: () => void) => () => void\n  }\n  readonly ms: number\n  readonly onCancel: Effect.Effect<void, never, unknown>\n}): Effect.Effect<void, never, unknown> =>\n  Effect.async<void, never, unknown>((resume) => {\n    let fired = false\n    const cancel = args.host.scheduleTimeout(args.ms, () => {\n      fired = true\n      // Route resumption through a microtask boundary:\n      // - Improves determinism in tests (deterministic HostScheduler).\n      // - Avoids deep JS-microtask chains that are invisible to HostScheduler flushing.\n      args.host.scheduleMicrotask(() => resume(Effect.void))\n    })\n    return Effect.sync(() => {\n      cancel()\n    }).pipe(Effect.zipRight(fired ? Effect.void : args.onCancel))\n  })\n\nconst ensureLimiterReady = (registry: WorkflowRegistryV1, runtime: PublicModuleRuntime<unknown, unknown>) =>\n  Effect.gen(function* () {\n    if (registry.parallelLimiter !== undefined) return\n\n    const internals = getRuntimeInternals(runtime)\n    const policy = yield* internals.concurrency.resolveConcurrencyPolicy()\n    const limit = policy.concurrencyLimit\n    if (limit === 'unbounded') {\n      registry.parallelLimiter = null\n      return\n    }\n\n    const n = typeof limit === 'number' && Number.isFinite(limit) && limit >= 1 ? Math.floor(limit) : 16\n    registry.parallelLimiter = yield* Effect.makeSemaphore(n)\n  })\n\nconst withRootEnvIfAvailable = <A, E, R>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>\n  Effect.gen(function* () {\n    const rootOpt = yield* Effect.serviceOption(RootContextTag)\n    if (Option.isNone(rootOpt)) {\n      return yield* eff\n    }\n    const root: RootContext = rootOpt.value\n    const rootEnv = root.context ?? (yield* Deferred.await(root.ready))\n\n    const currentEnv = yield* Effect.context<unknown>()\n    const mergedEnv = Context.merge(rootEnv as unknown as Context.Context<unknown>, currentEnv)\n    return yield* (Effect.provide(eff as unknown as Effect.Effect<A, E, unknown>, mergedEnv) as unknown as Effect.Effect<A, E, R>)\n  }) as unknown as Effect.Effect<A, E, R>\n\nconst ensurePortsResolved = (\n  registry: WorkflowRegistryV1,\n  runtime: PublicModuleRuntime<unknown, unknown>,\n): Effect.Effect<void, unknown, unknown> =>\n  Effect.gen(function* () {\n    const done = yield* Deferred.isDone(registry.portsReady)\n    if (done) {\n      yield* Deferred.await(registry.portsReady)\n      return\n    }\n\n    if (registry.portsResolving) {\n      yield* Deferred.await(registry.portsReady)\n      return\n    }\n\n    registry.portsResolving = true\n    const env = yield* Effect.context<unknown>()\n\n    yield* Effect.sync(() => {\n      const portCache = new Map<string, ServicePort>()\n      for (const entry of registry.entries) {\n        const program = entry.program\n        if (program.steps) continue\n\n        const resolvePort = (serviceId: string, stepKey: string): ServicePort => {\n          const cached = portCache.get(serviceId)\n          if (cached) return cached\n          const resolved = resolveServicePort(runtime, env, serviceId, program.programId, stepKey)\n          portCache.set(serviceId, resolved)\n          return resolved\n        }\n\n        program.steps = compileSteps(program.compiledSteps, resolvePort)\n      }\n    }).pipe(\n      Effect.tap(() => Deferred.succeed(registry.portsReady, undefined)),\n      Effect.catchAllCause((cause) => Deferred.failCause(registry.portsReady, cause).pipe(Effect.zipRight(Effect.failCause(cause)))),\n      Effect.ensuring(\n        Effect.sync(() => {\n          registry.portsResolving = false\n        }),\n      ),\n    )\n  })\n\nconst shouldObserveForRun = (diagnostics: Debug.DiagnosticsLevel, runSeq: number): boolean => {\n  if (diagnostics === 'off') return false\n  if (diagnostics === 'sampled') {\n    // Deterministic sampling (no Math.random): 1/16 by runSeq.\n    return (runSeq & 0x0f) === 0\n  }\n  return true\n}\n\nconst startProgramRun = (args: {\n  readonly entry: ProgramEntry\n  readonly runtime: PublicModuleRuntime<unknown, unknown>\n  readonly registry: WorkflowRegistryV1\n  readonly trigger: { readonly kind: 'action'; readonly actionTag: string } | { readonly kind: 'lifecycle'; readonly phase: string }\n  readonly payload: unknown\n  readonly middleware: EffectOpCore.EffectOpMiddlewareEnv | undefined\n}): Effect.Effect<void, never, unknown> =>\n  Effect.gen(function* () {\n    const { entry, runtime, registry } = args\n    const { program, state } = entry\n\n    const diagnostics = yield* FiberRef.get(Debug.currentDiagnosticsLevel)\n\n    const beginRun = (): { readonly runSeq: number; readonly runId: string; readonly canWriteBack: () => boolean } => {\n      if (state.mode === 'latest') {\n        state.runSeq += 1\n        const runSeq = state.runSeq\n        const runId = makeRunId(runtime.instanceId, program.programId, runSeq)\n        return {\n          runSeq,\n          runId,\n          canWriteBack: () => state.runSeq === runSeq,\n        }\n      }\n\n      state.runSeq += 1\n      const runSeq = state.runSeq\n      const runId = makeRunId(runtime.instanceId, program.programId, runSeq)\n      return {\n        runSeq,\n        runId,\n        canWriteBack: () => true,\n      }\n    }\n\n    if (state.mode === 'exhaust') {\n      if (state.busy) {\n        if (diagnostics !== 'off') {\n          const observe = shouldObserveForRun(diagnostics, state.runSeq)\n          const tickSeq = observe ? (yield* TickSchedulerTag).getTickSeq() : undefined\n          yield* runBoundary({\n            kind: 'flow',\n            name: 'workflow.drop',\n            payload: { programId: program.programId, trigger: args.trigger },\n            meta: {\n              moduleId: runtime.moduleId,\n              instanceId: runtime.instanceId,\n              programId: program.programId,\n              ...(tickSeq !== undefined ? { tickSeq } : null),\n              policy: { disableObservers: !observe },\n              reason: 'exhaust' as const,\n            },\n            effect: Effect.void,\n            middleware: args.middleware,\n          })\n        }\n        return\n      }\n      state.busy = true\n    }\n\n    const { runSeq, runId, canWriteBack } = beginRun()\n\n    if (state.mode === 'latest') {\n      const prev = state.current\n      const prevRunId = state.currentRunId\n      if (prev) {\n        yield* Fiber.interruptFork(prev)\n        if (diagnostics !== 'off') {\n          const observe = shouldObserveForRun(diagnostics, runSeq)\n          const tickSeq = observe ? (yield* TickSchedulerTag).getTickSeq() : undefined\n          yield* runBoundary({\n            kind: 'flow',\n            name: 'workflow.cancel',\n            payload: { programId: program.programId, cancelled: prevRunId, by: runId },\n            meta: {\n              moduleId: runtime.moduleId,\n              instanceId: runtime.instanceId,\n              programId: program.programId,\n              ...(tickSeq !== undefined ? { tickSeq } : null),\n              policy: { disableObservers: !observe },\n              reason: 'latest' as const,\n              cancelledByRunId: runId,\n              cancelledRunId: prevRunId,\n            },\n            effect: Effect.void,\n            middleware: args.middleware,\n          })\n        }\n      }\n      state.currentRunId = runId\n    }\n\n    const observe = shouldObserveForRun(diagnostics, runSeq)\n    const policy = { disableObservers: !observe } satisfies NonNullable<EffectOp.EffectOp['meta']>['policy']\n\n    const programEffect = Effect.gen(function* () {\n      const host = yield* HostSchedulerTag\n      const tick = yield* TickSchedulerTag\n\n      if (!program.steps) {\n        const env = yield* Effect.context<unknown>()\n        const portCache = new Map<string, ServicePort>()\n        const resolvePort = (serviceId: string, stepKey: string): ServicePort => {\n          const cached = portCache.get(serviceId)\n          if (cached) return cached\n          const resolved = resolveServicePort(runtime, env, serviceId, program.programId, stepKey)\n          portCache.set(serviceId, resolved)\n          return resolved\n        }\n        program.steps = compileSteps(program.compiledSteps, resolvePort)\n      }\n\n      const getTickSeq = (): number | undefined => (observe ? tick.getTickSeq() : undefined)\n      const emitTimerEvents = observe && diagnostics === 'full'\n\n      const evalPayload = (expr: CompiledInputExpr | undefined): unknown => (expr ? evalInputExpr(expr, args.payload) : undefined)\n\n      const defaultInputForCall = (): unknown =>\n        args.trigger.kind === 'action' ? args.payload : undefined\n\n      let timerTriggered = false\n\n      const runSteps = (steps: ReadonlyArray<CompiledRuntimeStep>): Effect.Effect<void, never, unknown> =>\n        Effect.gen(function* () {\n          for (const step of steps) {\n            if (!canWriteBack()) return\n\n            if (step.kind === 'dispatch') {\n              const payload = evalPayload(step.payload)\n              const action = { _tag: step.actionTag, payload }\n              const tickSeq = getTickSeq()\n\n              const dispatchEffectBase =\n                program.priority === 'nonUrgent' ? runtime.dispatchLowPriority(action) : runtime.dispatch(action)\n\n              const dispatchEffect = timerTriggered\n                ? Effect.locally(\n                    currentTxnOriginOverride,\n                    {\n                      kind: 'workflow.timer',\n                      name: `timer:${program.programId}:${step.key}`,\n                    },\n                  )(dispatchEffectBase)\n                : dispatchEffectBase\n\n              yield* runBoundary({\n                kind: 'flow',\n                name: 'workflow.dispatch',\n                payload: { actionTag: step.actionTag },\n                meta: {\n                  moduleId: runtime.moduleId,\n                  instanceId: runtime.instanceId,\n                  programId: program.programId,\n                  runId,\n                  stepKey: step.key,\n                  ...(tickSeq !== undefined ? { tickSeq } : null),\n                  policy,\n                },\n                effect: dispatchEffect,\n                middleware: args.middleware,\n              }).pipe(Effect.asVoid)\n              continue\n            }\n\n            if (step.kind === 'delay') {\n              const timerId = emitTimerEvents ? `${runId}::timer:${step.key}` : undefined\n\n              const recordTimerEvent = (name: string, patchMeta?: Record<string, unknown>) =>\n                Effect.gen(function* () {\n                  const tickSeq = getTickSeq()\n                  yield* runBoundary({\n                    kind: 'flow',\n                    name,\n                    payload: { ms: step.ms },\n                    meta: {\n                      moduleId: runtime.moduleId,\n                      instanceId: runtime.instanceId,\n                      programId: program.programId,\n                      runId,\n                      stepKey: step.key,\n                      ...(timerId ? { timerId } : null),\n                      ...(tickSeq !== undefined ? { tickSeq } : null),\n                      policy,\n                      ...(patchMeta ?? null),\n                    },\n                    effect: Effect.void,\n                    middleware: args.middleware,\n                  })\n                })\n\n              const schedule = emitTimerEvents ? recordTimerEvent('workflow.timer.schedule') : Effect.void\n              const onCancel = emitTimerEvents ? recordTimerEvent('workflow.timer.cancel', { reason: 'interrupt' }) : Effect.void\n              const fired = emitTimerEvents ? recordTimerEvent('workflow.timer.fired') : Effect.void\n\n              const delayEffect = schedule.pipe(\n                Effect.zipRight(makeTimer({ host, ms: step.ms, onCancel })),\n                Effect.zipRight(fired),\n              )\n\n              const tickSeq = getTickSeq()\n\n              yield* runBoundary({\n                kind: 'flow',\n                name: 'workflow.delay',\n                payload: { ms: step.ms },\n                meta: {\n                  moduleId: runtime.moduleId,\n                  instanceId: runtime.instanceId,\n                  programId: program.programId,\n                  runId,\n                  stepKey: step.key,\n                  ...(tickSeq !== undefined ? { tickSeq } : null),\n                  ...(timerId ? { timerId } : null),\n                  policy,\n                },\n                effect: delayEffect,\n                middleware: args.middleware,\n              }).pipe(Effect.asVoid)\n\n              timerTriggered = true\n              continue\n            }\n\n            // call\n            const input = step.input ? evalInputExpr(step.input, args.payload) : defaultInputForCall()\n            const maxRetries = step.retryTimes ?? 0\n            // Attempt id is 1-based and stable within a run.\n            let exit: Exit.Exit<unknown, unknown> | undefined\n            for (let attempt = 1; attempt <= maxRetries + 1; attempt += 1) {\n              const tickSeq = getTickSeq()\n\n              const base = runBoundary({\n                kind: 'service',\n                name: `workflow.call:${step.serviceId}`,\n                payload: { serviceId: step.serviceId },\n                meta: {\n                  moduleId: runtime.moduleId,\n                  instanceId: runtime.instanceId,\n                  programId: program.programId,\n                  runId,\n                  stepKey: step.key,\n                  serviceId: step.serviceId,\n                  attempt,\n                  ...(tickSeq !== undefined ? { tickSeq } : null),\n                  policy,\n                },\n                effect: step.port(input),\n                middleware: args.middleware,\n              })\n\n              const withTimeout =\n                step.timeoutMs === undefined\n                  ? base\n                  : Effect.gen(function* () {\n                      const timeoutMs = step.timeoutMs\n                      if (timeoutMs === undefined) {\n                        // Defensive: TS doesn't keep narrowing across generator boundaries.\n                        return yield* base\n                      }\n\n                      // Unique per attempt (otherwise retries would reuse the same timerId and break explainability).\n                      const timerId = emitTimerEvents ? `${runId}::timeout:${step.key}:a${attempt}` : undefined\n\n                      const recordTimeoutEvent = (name: string, patchMeta?: Record<string, unknown>) =>\n                        Effect.gen(function* () {\n                          const tickSeq = getTickSeq()\n                          yield* runBoundary({\n                            kind: 'flow',\n                            name,\n                            payload: { ms: timeoutMs },\n                            meta: {\n                              moduleId: runtime.moduleId,\n                              instanceId: runtime.instanceId,\n                              programId: program.programId,\n                              runId,\n                              stepKey: step.key,\n                              attempt,\n                              ...(timerId ? { timerId } : null),\n                              ...(tickSeq !== undefined ? { tickSeq } : null),\n                              policy,\n                              ...(patchMeta ?? null),\n                            },\n                            effect: Effect.void,\n                            middleware: args.middleware,\n                          })\n                        })\n\n                      const schedule = emitTimerEvents ? recordTimeoutEvent('workflow.timeout.schedule') : Effect.void\n                      const onCancel = emitTimerEvents\n                        ? recordTimeoutEvent('workflow.timeout.cancel', { reason: 'interrupt' })\n                        : Effect.void\n                      const fired = emitTimerEvents ? recordTimeoutEvent('workflow.timeout.fired') : Effect.void\n\n                      const timeoutError = makeWorkflowError({\n                        code: 'WORKFLOW_CALL_TIMEOUT',\n                        message: `Workflow call timed out (serviceId=\"${step.serviceId}\", timeoutMs=${timeoutMs}).`,\n                        programId: program.programId,\n                        source: { stepKey: step.key },\n                        detail: { serviceId: step.serviceId, timeoutMs, attempt },\n                      })\n\n                      const timeoutFail = schedule.pipe(\n                        Effect.zipRight(makeTimer({ host, ms: timeoutMs, onCancel })),\n                        Effect.zipRight(fired),\n                        Effect.zipRight(Effect.fail(timeoutError)),\n                      )\n\n                      return yield* Effect.raceFirst(base, timeoutFail)\n                    })\n\n              const attemptExit = yield* Effect.exit(withTimeout)\n              exit = attemptExit\n\n              if (!canWriteBack() || Exit.isSuccess(attemptExit)) {\n                break\n              }\n\n              // Do not retry defects/interrupts; only retry failure-channel errors.\n              if (Cause.isInterrupted(attemptExit.cause) || Option.isNone(Cause.failureOption(attemptExit.cause))) {\n                break\n              }\n\n              // Retry if we still have remaining attempts.\n              if (attempt < maxRetries + 1) {\n                continue\n              }\n\n              break\n            }\n\n            // Defensive: attempt loop always runs at least once.\n            if (!exit) {\n              exit = Exit.succeed(undefined) as Exit.Exit<unknown, unknown>\n            }\n\n            if (!canWriteBack()) return\n\n            if (Exit.isSuccess(exit)) {\n              yield* runSteps(step.onSuccess)\n            } else {\n              // Timeout uses a timer; mark the continuation as timer-triggered (for trace:tick.triggerSummary).\n              const failure = Option.getOrUndefined(Cause.failureOption(exit.cause))\n              const isTimeout =\n                isObjectLike(failure) &&\n                (failure as Record<string, unknown>)._tag === 'WorkflowError' &&\n                (failure as Record<string, unknown>).code === 'WORKFLOW_CALL_TIMEOUT'\n              if (isTimeout) timerTriggered = true\n              yield* runSteps(step.onFailure)\n            }\n          }\n        })\n\n      const runTickSeq = getTickSeq()\n      yield* runBoundary({\n        kind: 'flow',\n        name: 'workflow.run',\n        payload: { trigger: args.trigger },\n        meta: {\n          moduleId: runtime.moduleId,\n          instanceId: runtime.instanceId,\n          programId: program.programId,\n          runId,\n          ...(runTickSeq !== undefined ? { tickSeq: runTickSeq } : null),\n          policy,\n        },\n        effect: runSteps(program.steps!),\n        middleware: args.middleware,\n      }).pipe(Effect.asVoid)\n    })\n\n    const limited = registry.parallelLimiter ? registry.parallelLimiter.withPermits(1)(programEffect) : programEffect\n\n    const fiber = yield* Effect.forkScoped(\n      limited.pipe(\n        Effect.catchAllCause((cause) => {\n          const { errorSummary, downgrade } = toSerializableErrorSummary(cause)\n          const downgradeHint = downgrade ? ` (downgrade=${downgrade})` : ''\n          return Debug.record({\n            type: 'diagnostic',\n            moduleId: runtime.moduleId,\n            instanceId: runtime.instanceId,\n            code: 'workflow::run_crashed',\n            severity: 'error',\n            message: `Workflow run crashed for programId=\"${program.programId}\" runId=\"${runId}\".${downgradeHint}`,\n            hint: `${errorSummary.name ? `${errorSummary.name}: ` : ''}${errorSummary.message}`,\n            actionTag: args.trigger.kind === 'action' ? args.trigger.actionTag : undefined,\n            kind: 'workflow_run_crashed',\n            trigger: {\n              kind: 'workflow',\n              name: 'run',\n              details: {\n                programId: program.programId,\n                runId,\n                trigger: args.trigger,\n              },\n            },\n          }).pipe(Effect.catchAllCause(() => Effect.void))\n        }),\n        Effect.ensuring(\n          Effect.sync(() => {\n            if (state.mode === 'exhaust') {\n              state.busy = false\n            }\n          }),\n        ),\n      ),\n    )\n\n    if (state.mode === 'latest') {\n      state.current = fiber as Fiber.RuntimeFiber<void, never>\n    }\n  })\n\ntype RegistryInit = {\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly registry: WorkflowRegistryV1\n}\n\nconst ensureRegistry = (runtime: PublicModuleRuntime<unknown, unknown>) =>\n  Effect.gen(function* () {\n    const existing = getRegistry(runtime)\n    if (existing) {\n      return {\n        moduleId: runtime.moduleId,\n        instanceId: runtime.instanceId,\n        registry: existing,\n      }\n    }\n\n    const portsReady = yield* Deferred.make<void, unknown>()\n\n    const next: WorkflowRegistryV1 = {\n      byActionTag: new Map(),\n      entries: [],\n      watcherStarted: false,\n      watcherStartCount: 0,\n      portsResolving: false,\n      portsReady,\n      parallelLimiter: undefined,\n    }\n\n    Object.defineProperty(runtime, WORKFLOW_REGISTRY, {\n      value: next,\n      enumerable: false,\n      configurable: true,\n      writable: false,\n    })\n\n    return { moduleId: runtime.moduleId, instanceId: runtime.instanceId, registry: next }\n  })\n\nconst registerPrograms = (args: {\n  readonly moduleTag: ModuleTag\n  readonly programs: ReadonlyArray<WorkflowLike>\n  readonly entryLabel: string\n}): Effect.Effect<void, never, unknown> =>\n  Effect.gen(function* () {\n    const runtime = yield* args.moduleTag\n    const { moduleId, instanceId, registry } = yield* ensureRegistry(runtime)\n\n    // Lazily resolve the global parallel limiter once.\n    if (registry.parallelLimiter === undefined) {\n      yield* ensureLimiterReady(registry, runtime)\n    }\n\n    const validateNoIoStepsForOnInit = (steps: ReadonlyArray<CompiledWorkflowStep>, programId: string): void => {\n      const visit = (step: CompiledWorkflowStep): void => {\n        if (step.kind === 'call' || step.kind === 'delay') {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_INVALID_TRIGGER',\n            message: 'Lifecycle onInit programs must not include call/delay (initRequired must stay sync-only; use onStart for IO/time).',\n            programId,\n            source: { stepKey: step.key },\n            detail: { kind: step.kind },\n          })\n        }\n      }\n      for (const s of steps) visit(s)\n    }\n\n    const programHasCall = (steps: ReadonlyArray<CompiledWorkflowStep>): boolean =>\n      steps.some((s) => s.kind === 'call')\n\n    const insertEntry = (actionTag: string, entry: ProgramEntry): void => {\n      const prev = registry.byActionTag.get(actionTag)\n      registry.byActionTag.set(actionTag, prev ? [...prev, entry] : [entry])\n    }\n\n    const internals = getRuntimeInternals(runtime)\n\n    for (const program of args.programs) {\n      const def = program.def\n      const localId = asNonEmptyString(def.localId)\n      if (!localId) {\n        throw makeWorkflowError({\n          code: 'WORKFLOW_INVALID_DEF',\n          message: 'Workflow.install: def.localId must be a non-empty string.',\n          detail: { localId: def.localId },\n        })\n      }\n\n      const programId = `${moduleId}.${localId}`\n      const compiled = compileWorkflowRuntimeStepsV1({ def })\n\n      if (def.trigger.kind === 'lifecycle' && def.trigger.phase === 'onInit') {\n        validateNoIoStepsForOnInit(compiled, programId)\n      }\n\n      const compiledProgram: CompiledProgram = {\n        programId,\n        localId,\n        trigger: def.trigger,\n        concurrency: resolveConcurrency(def),\n        priority: resolvePriority(def),\n        compiledSteps: compiled,\n      }\n\n      if (!programHasCall(compiled)) {\n        compiledProgram.steps = compileSteps(compiled, () => {\n          throw makeWorkflowError({\n            code: 'WORKFLOW_MISSING_SERVICE',\n            message: 'Internal error: unexpected call step while resolving call-less program.',\n            programId,\n            detail: { programId },\n          })\n        })\n      }\n\n      const state: ProgramState =\n        compiledProgram.concurrency === 'latest'\n          ? { mode: 'latest', runSeq: 0, current: undefined, currentRunId: undefined }\n          : compiledProgram.concurrency === 'exhaust'\n            ? { mode: 'exhaust', runSeq: 0, busy: false }\n            : { mode: 'parallel', runSeq: 0 }\n\n      const entry: ProgramEntry = { program: compiledProgram, state }\n      registry.entries.push(entry)\n\n      if (def.trigger.kind === 'action') {\n        insertEntry(def.trigger.actionTag, entry)\n      } else {\n        if (def.trigger.phase === 'onStart') {\n          internals.lifecycle.registerStart(\n            withRootEnvIfAvailable(\n              Effect.gen(function* () {\n                const middlewareOpt = yield* Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag)\n                const middleware = Option.isSome(middlewareOpt) ? middlewareOpt.value : undefined\n                yield* ensurePortsResolved(registry, runtime).pipe(Effect.orDie)\n                yield* startProgramRun({\n                  entry,\n                  runtime,\n                  registry,\n                  trigger: { kind: 'lifecycle', phase: 'onStart' },\n                  payload: undefined,\n                  middleware,\n                })\n              }),\n            ),\n            { name: `workflow:${localId}` },\n          )\n        } else {\n          internals.lifecycle.registerInitRequired(\n            Effect.gen(function* () {\n              const middlewareOpt = yield* Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag)\n              const middleware = Option.isSome(middlewareOpt) ? middlewareOpt.value : undefined\n              yield* startProgramRun({\n                entry,\n                runtime,\n                registry,\n                trigger: { kind: 'lifecycle', phase: 'onInit' },\n                payload: undefined,\n                middleware,\n              })\n            }),\n            { name: `workflow:${localId}` },\n          )\n        }\n      }\n    }\n\n    void instanceId\n  })\n\nconst startWatcherIfNeeded = (args: {\n  readonly moduleTag: ModuleTag\n  readonly entryLabel: string\n}): Effect.Effect<void, never, unknown> =>\n  Effect.gen(function* () {\n    const runtime = yield* args.moduleTag\n    const init = yield* ensureRegistry(runtime)\n    const registry = init.registry\n\n    if (registry.watcherStarted) {\n      return\n    }\n\n    registry.watcherStarted = true\n    registry.watcherStartCount += 1\n\n    const middlewareOpt = yield* Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag)\n    const middleware = Option.isSome(middlewareOpt) ? middlewareOpt.value : undefined\n\n    const actions$ = runtime.actions$ as Stream.Stream<unknown>\n\n    const portsExit = yield* Effect.exit(ensurePortsResolved(registry, runtime))\n    if (Exit.isFailure(portsExit)) {\n      const { errorSummary, downgrade } = toSerializableErrorSummary(portsExit.cause)\n      const downgradeHint = downgrade ? ` (downgrade=${downgrade})` : ''\n      yield* Debug.record({\n        type: 'diagnostic',\n        moduleId: runtime.moduleId,\n        instanceId: runtime.instanceId,\n        code: 'workflow::ports_resolution_failed',\n        severity: 'error',\n        message: `Workflow ports resolution failed before starting watcher.${downgradeHint}`,\n        hint: `${errorSummary.name ? `${errorSummary.name}: ` : ''}${errorSummary.message}`,\n        kind: 'workflow_ports_resolution_failed',\n        trigger: {\n          kind: 'workflow',\n          name: 'portsResolution',\n          details: {\n            entryLabel: args.entryLabel,\n          },\n        },\n      })\n      return\n    }\n\n    yield* Stream.runForEach(actions$, (action) =>\n      Effect.gen(function* () {\n        const actionTag = resolveActionTag(action)\n        if (!actionTag) return\n\n        const entries = registry.byActionTag.get(actionTag)\n        if (!entries || entries.length === 0) return\n\n        const payload = isRecord(action) ? action.payload : undefined\n\n        yield* Effect.forEach(\n          entries,\n          (entry) =>\n            startProgramRun({\n              entry,\n              runtime,\n              registry,\n              trigger: { kind: 'action', actionTag },\n              payload,\n              middleware,\n            }),\n          { discard: true },\n        )\n      }),\n    ).pipe(\n      Effect.catchAllCause((cause) => {\n        const { errorSummary, downgrade } = toSerializableErrorSummary(cause)\n        const downgradeHint = downgrade ? ` (downgrade=${downgrade})` : ''\n        return Debug.record({\n          type: 'diagnostic',\n          moduleId: runtime.moduleId,\n          instanceId: runtime.instanceId,\n          code: 'workflow::watcher_crashed',\n          severity: 'error',\n          message: `Workflow watcher crashed.${downgradeHint}`,\n          hint: `${errorSummary.name ? `${errorSummary.name}: ` : ''}${errorSummary.message}`,\n          kind: 'workflow_watcher_crashed',\n          trigger: {\n            kind: 'workflow',\n            name: 'watcher',\n            details: {\n              entryLabel: args.entryLabel,\n            },\n          },\n        })\n      }),\n    )\n\n    void args.entryLabel\n  })\n\nexport const mountAll = (args: {\n  readonly moduleTag: ModuleTag\n  readonly programs: ReadonlyArray<WorkflowLike>\n}): LogicPlan<AnyModuleShape, unknown, never> => {\n  const plan = {\n    setup: registerPrograms({ moduleTag: args.moduleTag, programs: args.programs, entryLabel: 'mountAll' }),\n    run: startWatcherIfNeeded({ moduleTag: args.moduleTag, entryLabel: 'mountAll' }),\n  } satisfies LogicPlan<AnyModuleShape, unknown, never>\n\n  LogicUnitMeta.attachLogicUnitMeta(plan, {\n    id: '__logix_internal:workflows',\n    kind: 'internal',\n    name: 'workflows',\n  })\n\n  return plan\n}\n\nexport const installOne = (args: {\n  readonly moduleTag: ModuleTag\n  readonly program: WorkflowLike\n}): LogicPlan<AnyModuleShape, unknown, never> => {\n  const localId = asNonEmptyString(args.program.def.localId) ?? 'unknown'\n  const plan = {\n    setup: registerPrograms({ moduleTag: args.moduleTag, programs: [args.program], entryLabel: `install:${localId}` }),\n    run: startWatcherIfNeeded({ moduleTag: args.moduleTag, entryLabel: `install:${localId}` }),\n  } satisfies LogicPlan<AnyModuleShape, unknown, never>\n\n  LogicUnitMeta.attachLogicUnitMeta(plan, {\n    id: `workflow:${localId}`,\n    kind: 'workflow',\n    name: localId,\n  })\n\n  return plan\n}\n\n// test-only probe: whether a watcher has started (for single-subscription gates).\nexport const __unsafeGetWatcherStartCount = (runtime: unknown): number => {\n  if (!runtime || typeof runtime !== 'object') return 0\n  const reg = getRegistry(runtime)\n  return reg ? reg.watcherStartCount : 0\n}\n"],
  "mappings": "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",
  "names": ["runSeq", "runId", "observe", "tickSeq"]
}
