@logixjs/core 0.0.1 → 1.0.0

package/dist/chunk-PD6YECQH.js

@@ -0,0 +1,845 @@
+import {
+  compileWorkflowRuntimeStepsV1,
+  evalInputExpr,
+  makeWorkflowError
+} from "./chunk-3L6QGFMM.js";
+import {
+  attachLogicUnitMeta
+} from "./chunk-NUDBM4MM.js";
+import {
+  tagFromServiceId
+} from "./chunk-VJLWD47W.js";
+import {
+  RootContextTag
+} from "./chunk-YZDJMAKL.js";
+import {
+  getRuntimeInternals
+} from "./chunk-63ZQ5RIN.js";
+import {
+  HostSchedulerTag,
+  TickSchedulerTag,
+  forceSourceRefresh,
+  inSyncTransactionFiber
+} from "./chunk-S4S5N4BJ.js";
+import {
+  makeRunBudgetEnvelopeV1,
+  makeRunDegradeMarkerV1
+} from "./chunk-K6JQW266.js";
+import {
+  makeInRunSession,
+  run
+} from "./chunk-CYYSQMLO.js";
+import {
+  currentDiagnosticsLevel,
+  record,
+  toSerializableErrorSummary
+} from "./chunk-V2SBGVDO.js";
+import {
+  EffectOpMiddlewareTag
+} from "./chunk-LPPZDFTD.js";
+
+// src/internal/runtime/core/WorkflowRuntime.ts
+import { Cause, Deferred, Effect, Exit, Fiber, Option, Semaphore, ServiceMap, Stream } from "effect";
+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.provideService(handler(state), forceSourceRefresh, true) : handler(state);
+      const inTxn = yield* Effect.service(inSyncTransactionFiber).pipe(Effect.orDie);
+      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 = tagFromServiceId(serviceId);
+  const opt = ServiceMap.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 makeWorkflowRunBudgetMeta = (args) => ({
+  budgetEnvelope: makeRunBudgetEnvelopeV1({
+    domain: "workflow",
+    runId: args.runId
+  }),
+  degrade: makeRunDegradeMarkerV1(
+    !args.observed,
+    args.observed ? void 0 : args.diagnostics === "sampled" ? "sampled_out" : "observer_disabled"
+  )
+});
+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 makeWorkflowBoundaryRunner = (args) => {
+  const baseMeta = {
+    moduleId: args.runtime.moduleId,
+    instanceId: args.runtime.instanceId,
+    programId: args.programId
+  };
+  return (boundary) => runBoundary({
+    kind: boundary.kind,
+    name: boundary.name,
+    effect: boundary.effect,
+    payload: boundary.payload,
+    meta: {
+      ...baseMeta,
+      ...boundary.meta ?? null
+    },
+    middleware: args.middleware
+  });
+};
+var makeTimer = (args) => Effect.promise(
+  (signal) => new Promise((resolve) => {
+    let fired = false;
+    const cancel = args.ms <= 0 ? args.host.scheduleMacrotask(() => {
+      fired = true;
+      args.host.scheduleMicrotask(resolve);
+    }) : args.host.scheduleTimeout(args.ms, () => {
+      fired = true;
+      args.host.scheduleMicrotask(resolve);
+    });
+    const onAbort = () => {
+      cancel();
+      if (!fired) {
+        void Effect.runPromise(args.onCancel);
+      }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  })
+);
+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* Semaphore.make(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.services();
+  const mergedEnv = ServiceMap.merge(rootEnv, currentEnv);
+  return yield* Effect.provideServices(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.services();
+  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.catchCause((cause) => Deferred.failCause(registry.portsReady, cause).pipe(Effect.flatMap(() => 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 runWorkflowBoundary = makeWorkflowBoundaryRunner({
+    runtime,
+    programId: program.programId,
+    middleware: args.middleware
+  });
+  const diagnostics = yield* Effect.service(currentDiagnosticsLevel).pipe(Effect.orDie);
+  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 tickScheduler = yield* Effect.service(TickSchedulerTag).pipe(Effect.orDie);
+        const tickSeq = observe2 ? tickScheduler.getTickSeq() : void 0;
+        yield* runWorkflowBoundary({
+          kind: "flow",
+          name: "workflow.drop",
+          payload: { programId: program.programId, trigger: args.trigger },
+          meta: {
+            ...tickSeq !== void 0 ? { tickSeq } : null,
+            policy: { disableObservers: !observe2 },
+            reason: "exhaust"
+          },
+          effect: Effect.void
+        });
+      }
+      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.interrupt(prev);
+      if (diagnostics !== "off") {
+        const observe2 = shouldObserveForRun(diagnostics, runSeq);
+        const tickScheduler = yield* Effect.service(TickSchedulerTag).pipe(Effect.orDie);
+        const tickSeq = observe2 ? tickScheduler.getTickSeq() : void 0;
+        yield* runWorkflowBoundary({
+          kind: "flow",
+          name: "workflow.cancel",
+          payload: { programId: program.programId, cancelled: prevRunId, by: runId },
+          meta: {
+            ...makeWorkflowRunBudgetMeta({
+              runId,
+              diagnostics,
+              observed: observe2
+            }),
+            ...tickSeq !== void 0 ? { tickSeq } : null,
+            policy: { disableObservers: !observe2 },
+            reason: "latest",
+            cancelledByRunId: runId,
+            cancelledRunId: prevRunId
+          },
+          effect: Effect.void
+        });
+      }
+    }
+    state.currentRunId = runId;
+  }
+  const observe = shouldObserveForRun(diagnostics, runSeq);
+  const policy = { disableObservers: !observe };
+  const runBudgetMeta = makeWorkflowRunBudgetMeta({
+    runId,
+    diagnostics,
+    observed: observe
+  });
+  const programEffect = Effect.gen(function* () {
+    const host = yield* Effect.service(HostSchedulerTag).pipe(Effect.orDie);
+    const tick = yield* Effect.service(TickSchedulerTag).pipe(Effect.orDie);
+    if (!program.steps) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: `Workflow steps were not resolved before run (programId="${program.programId}").`,
+        programId: program.programId,
+        detail: { programId: program.programId }
+      });
+    }
+    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 timerOriginOverride = timerTriggered ? {
+            kind: "workflow.timer",
+            name: `timer:${program.programId}:${step.key}`
+          } : void 0;
+          const internals = timerOriginOverride ? getRuntimeInternals(runtime) : void 0;
+          const dispatchEffectBase = program.priority === "nonUrgent" ? timerOriginOverride ? internals.txn.dispatchLowPriorityWithOriginOverride(action, timerOriginOverride) : runtime.dispatchLowPriority(action) : timerOriginOverride ? internals.txn.dispatchWithOriginOverride(action, timerOriginOverride) : runtime.dispatch(action);
+          yield* runWorkflowBoundary({
+            kind: "flow",
+            name: "workflow.dispatch",
+            payload: { actionTag: step.actionTag },
+            meta: {
+              runId,
+              ...runBudgetMeta,
+              stepKey: step.key,
+              ...tickSeq !== void 0 ? { tickSeq } : null,
+              policy
+            },
+            effect: dispatchEffectBase
+          }).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* runWorkflowBoundary({
+              kind: "flow",
+              name,
+              payload: { ms: step.ms },
+              meta: {
+                runId,
+                ...runBudgetMeta,
+                stepKey: step.key,
+                ...timerId ? { timerId } : null,
+                ...tickSeq2 !== void 0 ? { tickSeq: tickSeq2 } : null,
+                policy,
+                ...patchMeta ?? null
+              },
+              effect: Effect.void
+            });
+          });
+          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.flatMap(() => makeTimer({ host, ms: step.ms, onCancel })),
+            Effect.flatMap(() => fired)
+          );
+          const tickSeq = getTickSeq();
+          yield* runWorkflowBoundary({
+            kind: "flow",
+            name: "workflow.delay",
+            payload: { ms: step.ms },
+            meta: {
+              runId,
+              ...runBudgetMeta,
+              stepKey: step.key,
+              ...tickSeq !== void 0 ? { tickSeq } : null,
+              ...timerId ? { timerId } : null,
+              policy
+            },
+            effect: delayEffect
+          }).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 = runWorkflowBoundary({
+            kind: "service",
+            name: `workflow.call:${step.serviceId}`,
+            payload: { serviceId: step.serviceId },
+            meta: {
+              runId,
+              ...runBudgetMeta,
+              stepKey: step.key,
+              serviceId: step.serviceId,
+              attempt,
+              ...tickSeq !== void 0 ? { tickSeq } : null,
+              policy
+            },
+            effect: step.port(input)
+          });
+          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* runWorkflowBoundary({
+                kind: "flow",
+                name,
+                payload: { ms: timeoutMs },
+                meta: {
+                  runId,
+                  ...runBudgetMeta,
+                  stepKey: step.key,
+                  attempt,
+                  ...timerId ? { timerId } : null,
+                  ...tickSeq2 !== void 0 ? { tickSeq: tickSeq2 } : null,
+                  policy,
+                  ...patchMeta ?? null
+                },
+                effect: Effect.void
+              });
+            });
+            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.flatMap(() => makeTimer({ host, ms: timeoutMs, onCancel })),
+              Effect.flatMap(() => fired),
+              Effect.flatMap(() => 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.hasInterruptsOnly(attemptExit.cause) || Option.isNone(Cause.findErrorOption(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.findErrorOption(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* runWorkflowBoundary({
+      kind: "flow",
+      name: "workflow.run",
+      payload: { trigger: args.trigger },
+      meta: {
+        runId,
+        ...runBudgetMeta,
+        ...runTickSeq !== void 0 ? { tickSeq: runTickSeq } : null,
+        policy
+      },
+      effect: runSteps(program.steps)
+    }).pipe(Effect.asVoid);
+  });
+  const limited = registry.parallelLimiter ? registry.parallelLimiter.withPermits(1)(programEffect) : programEffect;
+  const runOutsideTransaction = Effect.provideService(limited.pipe(
+    Effect.catchCause((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.catchCause(() => Effect.void));
+    }),
+    Effect.ensuring(
+      Effect.sync(() => {
+        if (state.mode === "exhaust") {
+          state.busy = false;
+        }
+      })
+    )
+  ), inSyncTransactionFiber, false);
+  const fiber = yield* runOutsideTransaction.pipe(Effect.forkScoped({ startImmediately: true }));
+  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* Effect.service(args.moduleTag).pipe(Effect.orDie);
+  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* Effect.service(args.moduleTag).pipe(Effect.orDie);
+  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) => Effect.provideService(effect, inSyncTransactionFiber, false),
+    Effect.catchCause((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=chunk-PD6YECQH.js.map