@logixjs/core 0.0.1 → 0.0.2

package/dist/Workflow.cjs

@@ -0,0 +1,2977 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Workflow.ts
+var Workflow_exports = {};
+__export(Workflow_exports, {
+  KernelPorts: () => KernelPorts,
+  call: () => call,
+  callById: () => callById,
+  compose: () => compose,
+  constValue: () => constValue,
+  delay: () => delay,
+  dispatch: () => dispatch,
+  forModule: () => forModule,
+  fragment: () => fragment,
+  fromJSON: () => fromJSON,
+  make: () => make,
+  merge: () => merge,
+  object: () => object,
+  onAction: () => onAction,
+  onInit: () => onInit,
+  onStart: () => onStart,
+  payload: () => payload,
+  payloadPath: () => payloadPath,
+  withPolicy: () => withPolicy
+});
+module.exports = __toCommonJS(Workflow_exports);
+var import_effect14 = require("effect");
+
+// src/internal/serviceId.ts
+var asNonEmptyString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var fromTag = (tag) => {
+  const anyTag = tag;
+  return asNonEmptyString(anyTag.key) ?? asNonEmptyString(anyTag.id) ?? asNonEmptyString(anyTag._id);
+};
+
+// src/internal/digest.ts
+var stableStringify = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const record2 = value;
+    const keys = Object.keys(record2).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record2[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
+
+// src/internal/observability/jsonValue.ts
+var isJsonValue = (input) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const loop = (value, depth) => {
+    if (depth > 64) return false;
+    if (value === null) return true;
+    switch (typeof value) {
+      case "string":
+      case "boolean":
+        return true;
+      case "number":
+        return Number.isFinite(value);
+      case "object": {
+        if (Array.isArray(value)) {
+          if (seen.has(value)) return false;
+          seen.add(value);
+          for (const item of value) {
+            if (!loop(item, depth + 1)) return false;
+          }
+          return true;
+        }
+        if (!isPlainRecord(value)) return false;
+        if (seen.has(value)) return false;
+        seen.add(value);
+        for (const v of Object.values(value)) {
+          if (!loop(v, depth + 1)) return false;
+        }
+        return true;
+      }
+      default:
+        return false;
+    }
+  };
+  return loop(input, 0);
+};
+var defaultOptions = {
+  maxDepth: 6,
+  maxObjectKeys: 32,
+  maxArrayLength: 32,
+  maxStringLength: 256,
+  maxJsonBytes: 4 * 1024,
+  oversizedPreviewBytes: 256
+};
+var truncateString = (value, maxLen, stats) => {
+  if (value.length <= maxLen) return value;
+  stats.oversized += 1;
+  return value.slice(0, maxLen);
+};
+var mergeDowngrade = (current, next) => {
+  if (!current) return next;
+  if (current === "non_serializable" || next === "non_serializable") return "non_serializable";
+  if (current === "oversized" || next === "oversized") return "oversized";
+  return "unknown";
+};
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var asNumber = (value, stats) => {
+  if (Number.isFinite(value)) return value;
+  stats.nonSerializable += 1;
+  return String(value);
+};
+var toJsonValueInternal = (input, options, stats, seen, depth) => {
+  if (input === null) return null;
+  switch (typeof input) {
+    case "string":
+      return truncateString(input, options.maxStringLength, stats);
+    case "number":
+      return asNumber(input, stats);
+    case "boolean":
+      return input;
+    case "bigint":
+      stats.nonSerializable += 1;
+      return truncateString(input.toString(), options.maxStringLength, stats);
+    case "symbol":
+      stats.nonSerializable += 1;
+      return truncateString(input.toString(), options.maxStringLength, stats);
+    case "function":
+      stats.nonSerializable += 1;
+      return "[Function]";
+    case "undefined":
+      stats.dropped += 1;
+      return null;
+  }
+  if (depth >= options.maxDepth) {
+    stats.oversized += 1;
+    return "[Truncated]";
+  }
+  if (input instanceof Date) {
+    return input.toISOString();
+  }
+  if (input instanceof Error) {
+    stats.nonSerializable += 1;
+    return {
+      name: truncateString(input.name, options.maxStringLength, stats),
+      message: truncateString(input.message, options.maxStringLength, stats)
+    };
+  }
+  if (typeof input === "object") {
+    if (seen.has(input)) {
+      stats.nonSerializable += 1;
+      return "[Circular]";
+    }
+    seen.add(input);
+  }
+  if (Array.isArray(input)) {
+    const out2 = [];
+    const limit2 = Math.min(input.length, options.maxArrayLength);
+    for (let i = 0; i < limit2; i++) {
+      out2.push(toJsonValueInternal(input[i], options, stats, seen, depth + 1));
+    }
+    if (input.length > limit2) {
+      stats.oversized += 1;
+      out2.push(`[...${input.length - limit2} more]`);
+    }
+    return out2;
+  }
+  if (!isPlainRecord(input)) {
+    stats.nonSerializable += 1;
+    return truncateString(String(input), options.maxStringLength, stats);
+  }
+  const keys = Object.keys(input).sort();
+  const limit = Math.min(keys.length, options.maxObjectKeys);
+  const out = {};
+  for (let i = 0; i < limit; i++) {
+    const rawKey = keys[i];
+    const rawValue = input[rawKey];
+    const key = truncateString(rawKey, options.maxStringLength, stats);
+    if (rawValue === void 0) {
+      stats.dropped += 1;
+      continue;
+    }
+    out[key] = toJsonValueInternal(rawValue, options, stats, seen, depth + 1);
+  }
+  if (keys.length > limit) {
+    stats.oversized += 1;
+    out.__truncatedKeys = keys.length - limit;
+  }
+  return out;
+};
+var projectJsonValue = (input, options) => {
+  const resolved = { ...defaultOptions, ...options ?? {} };
+  const stats = { dropped: 0, oversized: 0, nonSerializable: 0 };
+  const seen = /* @__PURE__ */ new WeakSet();
+  let downgrade;
+  const value = toJsonValueInternal(input, resolved, stats, seen, 0);
+  if (stats.nonSerializable > 0) {
+    downgrade = mergeDowngrade(downgrade, "non_serializable");
+  }
+  if (stats.oversized > 0) {
+    downgrade = mergeDowngrade(downgrade, "oversized");
+  }
+  try {
+    const json = JSON.stringify(value);
+    if (json.length > resolved.maxJsonBytes) {
+      downgrade = mergeDowngrade(downgrade, "oversized");
+      const preview = json.slice(0, Math.min(resolved.oversizedPreviewBytes, resolved.maxJsonBytes));
+      return {
+        value: {
+          _tag: "oversized",
+          bytes: json.length,
+          preview
+        },
+        stats: {
+          dropped: stats.dropped,
+          oversized: stats.oversized + 1,
+          nonSerializable: stats.nonSerializable
+        },
+        downgrade
+      };
+    }
+  } catch {
+    downgrade = mergeDowngrade(downgrade, "non_serializable");
+    return {
+      value: "[Unserializable]",
+      stats: {
+        dropped: stats.dropped,
+        oversized: stats.oversized,
+        nonSerializable: stats.nonSerializable + 1
+      },
+      downgrade
+    };
+  }
+  return {
+    value,
+    stats: {
+      dropped: stats.dropped,
+      oversized: stats.oversized,
+      nonSerializable: stats.nonSerializable
+    },
+    downgrade
+  };
+};
+
+// src/internal/workflow/errors.ts
+var toJsonValue = (detail) => {
+  if (isJsonValue(detail)) return detail;
+  return projectJsonValue(detail).value;
+};
+var makeWorkflowError = (args) => {
+  const detailJson = args.detail !== void 0 ? toJsonValue(args.detail) : void 0;
+  const msg = args.detail !== void 0 ? `${args.message}
+(detail=${stableStringify(detailJson)})` : args.message;
+  return Object.assign(new Error(msg), {
+    _tag: "WorkflowError",
+    code: args.code,
+    programId: args.programId,
+    source: args.source,
+    detail: detailJson
+  });
+};
+
+// src/internal/workflow/inputExpr.ts
+var decodePointerToken = (raw) => raw.replace(/~1/g, "/").replace(/~0/g, "~");
+var isIndexToken = (token) => token === "0" || !token.startsWith("0") && /^\d+$/.test(token);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseJsonPointer = (pointer) => {
+  if (pointer === "") return [];
+  if (!pointer.startsWith("/")) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_JSON_POINTER",
+      message: 'Invalid JSON Pointer (must be "" or start with "/").',
+      detail: { pointer }
+    });
+  }
+  const raw = pointer.split("/").slice(1);
+  const out = [];
+  for (const part of raw) {
+    const decoded = decodePointerToken(part);
+    out.push(isIndexToken(decoded) ? Number(decoded) : decoded);
+  }
+  return out;
+};
+var compileInputExpr = (expr, pathForError) => {
+  switch (expr.kind) {
+    case "payload":
+      return { kind: "payload" };
+    case "payload.path": {
+      const pointer = expr.pointer;
+      if (typeof pointer !== "string") {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.payload.path.pointer must be a string.",
+          source: { stepKey: pathForError?.stepKey },
+          detail: { pointer }
+        });
+      }
+      return { kind: "payload.path", pointer, tokens: parseJsonPointer(pointer) };
+    }
+    case "const": {
+      const value = expr.value;
+      if (!isJsonValue(value)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.const.value must be JSON-serializable.",
+          source: { stepKey: pathForError?.stepKey },
+          detail: { value }
+        });
+      }
+      return { kind: "const", value };
+    }
+    case "object": {
+      const fields = expr.fields;
+      if (!fields || typeof fields !== "object" || Array.isArray(fields)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.object.fields must be a record.",
+          source: { stepKey: pathForError?.stepKey }
+        });
+      }
+      const entries = Object.entries(fields).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+      return {
+        kind: "object",
+        fields: entries.map(([k, v]) => [k, compileInputExpr(v, pathForError)])
+      };
+    }
+    case "merge": {
+      const items = expr.items;
+      if (!Array.isArray(items)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "InputExpr.merge.items must be an array.",
+          source: { stepKey: pathForError?.stepKey }
+        });
+      }
+      for (const item of items) {
+        const kind = isRecord(item) ? item.kind : void 0;
+        if (kind !== "object") {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_MERGE_ITEMS",
+            message: "InputExpr.merge.items must all be InputExpr.object.",
+            source: { stepKey: pathForError?.stepKey },
+            detail: { kind }
+          });
+        }
+      }
+      return {
+        kind: "merge",
+        items: items.map((i) => compileInputExpr(i, pathForError))
+      };
+    }
+  }
+};
+var isPlainRecord2 = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var evalPointer = (root, tokens) => {
+  let current = root;
+  for (const token of tokens) {
+    if (current == null) return void 0;
+    if (Array.isArray(current) && typeof token === "number") {
+      current = current[token];
+      continue;
+    }
+    if (typeof current !== "object") return void 0;
+    const key = typeof token === "number" ? String(token) : token;
+    current = current[key];
+  }
+  return current;
+};
+var evalInputExpr = (expr, payload2) => {
+  switch (expr.kind) {
+    case "payload":
+      return payload2;
+    case "payload.path":
+      return evalPointer(payload2, expr.tokens);
+    case "const":
+      return expr.value;
+    case "object": {
+      const out = {};
+      for (const [k, v] of expr.fields) {
+        out[k] = evalInputExpr(v, payload2);
+      }
+      return out;
+    }
+    case "merge": {
+      const out = {};
+      for (const item of expr.items) {
+        const value = evalInputExpr(item, payload2);
+        if (isPlainRecord2(value)) {
+          for (const [k, v] of Object.entries(value)) {
+            out[k] = v;
+          }
+        }
+      }
+      return out;
+    }
+  }
+};
+
+// src/internal/workflow/compiler.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var asNonEmptyString2 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var asNonNegInt = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n >= 0 ? n : void 0;
+};
+var asPosInt = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n > 0 ? n : void 0;
+};
+var normalizeWorkflowDefV1 = (input) => {
+  const normalizeStep = (step) => {
+    if (!isRecord2(step)) return step;
+    if (step.kind !== "call") return step;
+    const raw = step;
+    const onSuccessRaw = Array.isArray(raw.onSuccess) ? raw.onSuccess : [];
+    const onFailureRaw = Array.isArray(raw.onFailure) ? raw.onFailure : [];
+    return {
+      ...step,
+      onSuccess: onSuccessRaw.map(normalizeStep),
+      onFailure: onFailureRaw.map(normalizeStep)
+    };
+  };
+  const normalizeSteps = (steps) => steps.map(normalizeStep);
+  return {
+    ...input,
+    steps: normalizeSteps(input.steps)
+  };
+};
+function validateWorkflowDefV1(def, options) {
+  if (!isRecord2(def)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef must be an object.",
+      detail: { def }
+    });
+  }
+  if (def.astVersion !== 1) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_UNSUPPORTED_VERSION",
+      message: "Unsupported workflow astVersion.",
+      detail: { astVersion: def.astVersion }
+    });
+  }
+  if (!asNonEmptyString2(def.localId)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef.localId must be a non-empty string.",
+      detail: { localId: def.localId }
+    });
+  }
+  const trigger = def.trigger;
+  if (!isRecord2(trigger)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_TRIGGER",
+      message: "Workflow trigger must be an object.",
+      detail: { trigger }
+    });
+  }
+  if (trigger.kind === "action") {
+    if (!asNonEmptyString2(trigger.actionTag)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_TRIGGER",
+        message: "Workflow trigger.actionTag must be a non-empty string.",
+        detail: { trigger }
+      });
+    }
+  } else if (trigger.kind === "lifecycle") {
+    const phase = trigger.phase;
+    if (phase !== "onStart" && phase !== "onInit") {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_TRIGGER",
+        message: 'Workflow trigger.phase must be "onStart" or "onInit".',
+        detail: { trigger }
+      });
+    }
+  } else {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_TRIGGER",
+      message: 'Workflow trigger.kind must be "action" or "lifecycle".',
+      detail: { trigger }
+    });
+  }
+  if (!Array.isArray(def.steps)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef.steps must be an array.",
+      detail: { steps: def.steps }
+    });
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const visit = (step, fragmentId) => {
+    if (!isRecord2(step)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_STEP",
+        message: "Workflow step must be an object.",
+        detail: { step },
+        source: fragmentId ? { fragmentId } : void 0
+      });
+    }
+    const key = asNonEmptyString2(step.key);
+    if (!key) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_STEP",
+        message: "Workflow step.key must be a non-empty string.",
+        detail: { stepKey: step.key, kind: step.kind },
+        source: fragmentId ? { fragmentId } : void 0
+      });
+    }
+    if (seenKeys.has(key)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_DUPLICATE_STEP_KEY",
+        message: `Duplicate stepKey "${key}" detected.`,
+        detail: { duplicateKey: key },
+        source: { stepKey: key, ...fragmentId ? { fragmentId } : null }
+      });
+    }
+    seenKeys.add(key);
+    if (step.kind === "dispatch") {
+      if (!asNonEmptyString2(step.actionTag)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_STEP",
+          message: "dispatch.actionTag must be a non-empty string.",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { actionTag: step.actionTag }
+        });
+      }
+      const payload2 = step.payload;
+      if (payload2 !== void 0) {
+        validateInputExpr(payload2, { stepKey: key });
+      }
+      return;
+    }
+    if (step.kind === "delay") {
+      const ms = asNonNegInt(step.ms);
+      if (ms === void 0) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_STEP",
+          message: "delay.ms must be a non-negative integer.",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { ms: step.ms }
+        });
+      }
+      return;
+    }
+    if (step.kind === "call") {
+      if (!asNonEmptyString2(step.serviceId)) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_SERVICE_ID",
+          message: "call.serviceId must be a non-empty string.",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { serviceId: step.serviceId }
+        });
+      }
+      const inputExpr = step.input;
+      if (inputExpr !== void 0) {
+        validateInputExpr(inputExpr, { stepKey: key });
+      }
+      const timeoutMsRaw = step.timeoutMs;
+      if (timeoutMsRaw !== void 0 && asPosInt(timeoutMsRaw) === void 0) {
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_STEP",
+          message: "call.timeoutMs must be a positive integer (milliseconds).",
+          source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+          detail: { timeoutMs: timeoutMsRaw }
+        });
+      }
+      const retryRaw = step.retry;
+      if (retryRaw !== void 0) {
+        const times = isRecord2(retryRaw) ? asPosInt(retryRaw.times) : void 0;
+        if (times === void 0) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_STEP",
+            message: "call.retry.times must be a positive integer.",
+            source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+            detail: { retry: retryRaw }
+          });
+        }
+      }
+      const onSuccess = Array.isArray(step.onSuccess) ? step.onSuccess : [];
+      const onFailure = Array.isArray(step.onFailure) ? step.onFailure : [];
+      for (const inner of onSuccess) visit(inner, fragmentId);
+      for (const inner of onFailure) visit(inner, fragmentId);
+      return;
+    }
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_STEP",
+      message: "Unknown step kind.",
+      source: { stepKey: key, ...fragmentId ? { fragmentId } : null },
+      detail: { kind: step.kind }
+    });
+  };
+  const sources = def.sources;
+  const fragmentByStepKey = /* @__PURE__ */ new Map();
+  if (sources && typeof sources === "object") {
+    for (const [k, v] of Object.entries(sources)) {
+      fragmentByStepKey.set(k, isRecord2(v) ? asNonEmptyString2(v.fragmentId) : void 0);
+    }
+  }
+  for (const step of def.steps) {
+    const key = isRecord2(step) ? asNonEmptyString2(step.key) : void 0;
+    const fragmentId = key ? fragmentByStepKey.get(key) : void 0;
+    visit(step, fragmentId);
+  }
+  const generator = isRecord2(def.meta) ? def.meta.generator : void 0;
+  if (generator !== void 0 && !isJsonValue(generator)) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "WorkflowDef.meta.generator must be JSON-serializable.",
+      detail: { generator }
+    });
+  }
+  const policy = isRecord2(def.policy) ? def.policy : void 0;
+  if (policy) {
+    const concurrency = policy.concurrency;
+    if (concurrency !== void 0 && concurrency !== "latest" && concurrency !== "exhaust" && concurrency !== "parallel") {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: "policy.concurrency must be latest|exhaust|parallel.",
+        detail: { concurrency }
+      });
+    }
+    const priority = policy.priority;
+    if (priority !== void 0 && priority !== "urgent" && priority !== "nonUrgent") {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: "policy.priority must be urgent|nonUrgent.",
+        detail: { priority }
+      });
+    }
+  }
+  void options?.moduleId;
+}
+var validateInputExpr = (expr, options) => {
+  const visit = (e) => {
+    if (!isRecord2(e)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_INPUT_EXPR",
+        message: "InputExpr must be an object.",
+        source: { stepKey: options?.stepKey },
+        detail: { expr: e }
+      });
+    }
+    const kind = e.kind;
+    switch (kind) {
+      case "payload":
+        return;
+      case "payload.path": {
+        const pointer = e.pointer;
+        if (typeof pointer !== "string") {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.payload.path.pointer must be a string.",
+            source: { stepKey: options?.stepKey },
+            detail: { pointer }
+          });
+        }
+        return;
+      }
+      case "const": {
+        const value = e.value;
+        if (!isJsonValue(value)) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.const.value must be JSON-serializable.",
+            source: { stepKey: options?.stepKey }
+          });
+        }
+        return;
+      }
+      case "object": {
+        const fields = e.fields;
+        if (!isRecord2(fields)) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.object.fields must be a record.",
+            source: { stepKey: options?.stepKey }
+          });
+        }
+        for (const v of Object.values(fields)) {
+          visit(v);
+        }
+        return;
+      }
+      case "merge": {
+        const items = e.items;
+        if (!Array.isArray(items)) {
+          throw makeWorkflowError({
+            code: "WORKFLOW_INVALID_INPUT_EXPR",
+            message: "InputExpr.merge.items must be an array.",
+            source: { stepKey: options?.stepKey }
+          });
+        }
+        for (const item of items) {
+          visit(item);
+        }
+        return;
+      }
+      default:
+        throw makeWorkflowError({
+          code: "WORKFLOW_INVALID_INPUT_EXPR",
+          message: "Unknown InputExpr kind.",
+          source: { stepKey: options?.stepKey },
+          detail: { kind }
+        });
+    }
+  };
+  visit(expr);
+};
+var makeDigest = (prefix, value) => `${prefix}:${fnv1a32(stableStringify(value))}`;
+var makeTriggerNodeId = (programId) => `wf_trigger_v1:${fnv1a32(programId)}`;
+var makeStepNodeId = (programId, stepKey, kind) => `wf_node_v1:${fnv1a32(`${programId}\0${stepKey}\0${kind}`)}`;
+var budgetJsonValue = (value) => projectJsonValue(value).value;
+var budgetInputExpr = (expr) => {
+  switch (expr.kind) {
+    case "payload":
+    case "payload.path":
+      return expr;
+    case "const": {
+      const value = expr.value;
+      if (!isJsonValue(value)) return expr;
+      return { ...expr, value: budgetJsonValue(expr.value) };
+    }
+    case "object": {
+      const out = {};
+      for (const k of Object.keys(expr.fields).sort()) {
+        out[k] = budgetInputExpr(expr.fields[k]);
+      }
+      return { ...expr, fields: out };
+    }
+    case "merge":
+      return { ...expr, items: expr.items.map(budgetInputExpr) };
+  }
+};
+var toStaticStep = (step) => {
+  switch (step.kind) {
+    case "dispatch":
+      return {
+        kind: "dispatch",
+        actionTag: step.actionTag,
+        ...step.payload ? { payload: budgetInputExpr(step.payload) } : null
+      };
+    case "delay":
+      return { kind: "delay", ms: step.ms };
+    case "call": {
+      const policy = step.timeoutMs !== void 0 || step.retry !== void 0 ? {
+        ...step.timeoutMs !== void 0 ? { timeoutMs: step.timeoutMs } : null,
+        ...step.retry !== void 0 ? { retry: { times: step.retry.times } } : null
+      } : void 0;
+      return {
+        kind: "call",
+        serviceId: step.serviceId,
+        ...step.input ? { input: budgetInputExpr(step.input) } : null,
+        ...policy ? { policy } : null
+      };
+    }
+  }
+};
+var compileWorkflowStaticIrV1 = (args) => {
+  const normalized = normalizeWorkflowDefV1(args.def);
+  validateWorkflowDefV1(normalized, { moduleId: args.moduleId });
+  const programId = `${args.moduleId}.${normalized.localId}`;
+  const triggerNodeId = makeTriggerNodeId(programId);
+  const fragmentByStepKey = /* @__PURE__ */ new Map();
+  if (normalized.sources && typeof normalized.sources === "object") {
+    for (const [k, v] of Object.entries(normalized.sources)) {
+      fragmentByStepKey.set(k, isRecord2(v) ? asNonEmptyString2(v.fragmentId) : void 0);
+    }
+  }
+  const nodesByKey = /* @__PURE__ */ new Map();
+  const collectNodes = (steps) => {
+    for (const step of steps) {
+      const id = makeStepNodeId(programId, step.key, step.kind);
+      nodesByKey.set(step.key, id);
+      if (step.kind === "call") {
+        collectNodes(step.onSuccess);
+        collectNodes(step.onFailure);
+      }
+    }
+  };
+  collectNodes(normalized.steps);
+  const nodes = [
+    {
+      id: triggerNodeId,
+      kind: "trigger",
+      trigger: normalized.trigger
+    }
+  ];
+  const addStepNodes = (steps) => {
+    for (const step of steps) {
+      const id = nodesByKey.get(step.key);
+      if (!id) continue;
+      const fragmentId = fragmentByStepKey.get(step.key);
+      nodes.push({
+        id,
+        kind: "step",
+        step: toStaticStep(step),
+        source: {
+          stepKey: step.key,
+          ...fragmentId ? { fragmentId } : null
+        }
+      });
+      if (step.kind === "call") {
+        addStepNodes(step.onSuccess);
+        addStepNodes(step.onFailure);
+      }
+    }
+  };
+  addStepNodes(normalized.steps);
+  const edges = [];
+  const pushEdge = (from, to, kind) => {
+    edges.push({ from, to, kind });
+  };
+  const compileBlock = (args2) => {
+    if (args2.steps.length === 0) {
+      if (args2.continuation) {
+        for (const from of args2.entryFrom) {
+          pushEdge(from, args2.continuation, args2.entryKind);
+        }
+      }
+      return;
+    }
+    const first = args2.steps[0];
+    const firstId = nodesByKey.get(first.key);
+    if (!firstId) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_STEP",
+        message: "Internal error: missing node id for stepKey.",
+        programId,
+        source: { stepKey: first.key }
+      });
+    }
+    for (const from of args2.entryFrom) {
+      pushEdge(from, firstId, args2.entryKind);
+    }
+    const compileStepAndTail = (step, tail, continuation) => {
+      const stepId = nodesByKey.get(step.key);
+      if (!stepId) return;
+      if (step.kind !== "call") {
+        compileBlock({ steps: tail, entryFrom: [stepId], entryKind: "next", continuation });
+        return;
+      }
+      const cont = tail.length > 0 ? nodesByKey.get(tail[0].key) : continuation;
+      compileBlock({
+        steps: step.onSuccess,
+        entryFrom: [stepId],
+        entryKind: "success",
+        continuation: cont
+      });
+      compileBlock({
+        steps: step.onFailure,
+        entryFrom: [stepId],
+        entryKind: "failure",
+        continuation: cont
+      });
+      compileBlock({ steps: tail, entryFrom: [], entryKind: "next", continuation });
+    };
+    compileStepAndTail(first, args2.steps.slice(1), args2.continuation);
+  };
+  compileBlock({ steps: normalized.steps, entryFrom: [triggerNodeId], entryKind: "next", continuation: void 0 });
+  nodes.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  edges.sort((a, b) => {
+    if (a.from !== b.from) return a.from < b.from ? -1 : 1;
+    if (a.to !== b.to) return a.to < b.to ? -1 : 1;
+    const ak = String(a.kind ?? "");
+    const bk = String(b.kind ?? "");
+    if (ak !== bk) return ak < bk ? -1 : 1;
+    return 0;
+  });
+  const meta = (() => {
+    const generator = normalized.meta?.generator;
+    if (generator === void 0) return void 0;
+    return { generator: budgetJsonValue(generator) };
+  })();
+  const irNoDigest = {
+    version: 1,
+    programId,
+    nodes,
+    edges,
+    policy: normalized.policy,
+    meta
+  };
+  const digest = makeDigest("workflow_ir_v1", irNoDigest);
+  return {
+    ...irNoDigest,
+    digest
+  };
+};
+var compileWorkflowRuntimeStepsV1 = (args) => {
+  const normalized = normalizeWorkflowDefV1(args.def);
+  validateWorkflowDefV1(normalized);
+  const compileStep = (step) => {
+    const stepKey = step.key;
+    switch (step.kind) {
+      case "dispatch":
+        return {
+          kind: "dispatch",
+          key: step.key,
+          actionTag: step.actionTag,
+          ...step.payload ? { payload: compileInputExpr(step.payload, { stepKey }) } : null
+        };
+      case "delay":
+        return { kind: "delay", key: step.key, ms: step.ms };
+      case "call": {
+        const retryTimes = step.retry?.times;
+        return {
+          kind: "call",
+          key: step.key,
+          serviceId: step.serviceId,
+          ...step.input ? { input: compileInputExpr(step.input, { stepKey }) } : null,
+          ...step.timeoutMs !== void 0 ? { timeoutMs: step.timeoutMs } : null,
+          ...retryTimes !== void 0 ? { retryTimes } : null,
+          onSuccess: step.onSuccess.map(compileStep),
+          onFailure: step.onFailure.map(compileStep)
+        };
+      }
+    }
+  };
+  return normalized.steps.map(compileStep);
+};
+
+// src/internal/runtime/core/WorkflowRuntime.ts
+var import_effect13 = require("effect");
+
+// src/internal/runtime/core/EffectOpCore.ts
+var import_effect = require("effect");
+var currentLinkId = import_effect.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect.Context.Tag("Logix/EffectOpMiddleware")() {
+};
+var composeMiddleware = (stack) => {
+  return (op) => stack.reduceRight(
+    (eff, mw) => mw({ ...op, effect: eff }),
+    op.effect
+  );
+};
+var runWithMiddleware = (op, stack) => {
+  return import_effect.Effect.gen(function* () {
+    const existing = yield* import_effect.FiberRef.get(currentLinkId);
+    const metaLinkId = op.meta?.linkId;
+    const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
+    const nextOp = {
+      ...op,
+      meta: {
+        ...op.meta ?? {},
+        linkId
+      }
+    };
+    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
+    return yield* import_effect.Effect.locally(currentLinkId, linkId)(program);
+  });
+};
+
+// src/internal/runtime/core/DebugSink.record.ts
+var import_effect3 = require("effect");
+
+// src/internal/runtime/core/errorSummary.ts
+var import_effect2 = require("effect");
+var truncate = (value, maxLen) => {
+  if (value.length <= maxLen) return { value, truncated: false };
+  return { value: value.slice(0, maxLen), truncated: true };
+};
+var safeStringify = (value) => {
+  try {
+    return { ok: true, json: JSON.stringify(value) };
+  } catch {
+    return { ok: false };
+  }
+};
+var getMessageFromUnknown = (cause) => {
+  if (typeof cause === "string") return cause;
+  if (typeof cause === "number" || typeof cause === "boolean" || typeof cause === "bigint") return String(cause);
+  if (cause instanceof Error) return cause.message || cause.name || "Error";
+  if (cause && typeof cause === "object" && "message" in cause && typeof cause.message === "string") {
+    return cause.message;
+  }
+  try {
+    const pretty = import_effect2.Cause.pretty(cause, { renderErrorCause: true });
+    if (typeof pretty === "string" && pretty.length > 0) return pretty;
+  } catch {
+  }
+  return "Unknown error";
+};
+var toSerializableErrorSummary = (cause, options) => {
+  const maxMessageLength = options?.maxMessageLength ?? 256;
+  const messageRaw = getMessageFromUnknown(cause);
+  const { value: message, truncated } = truncate(messageRaw, maxMessageLength);
+  const summary = {
+    message
+  };
+  if (cause instanceof Error) {
+    if (cause.name && cause.name !== "Error") summary.name = cause.name;
+    const anyCause = cause;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    else if (typeof anyCause.code === "number" && Number.isFinite(anyCause.code)) summary.code = String(anyCause.code);
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+    return {
+      errorSummary: summary,
+      downgrade: truncated ? "oversized" : void 0
+    };
+  }
+  if (cause && typeof cause === "object") {
+    const anyCause = cause;
+    if (typeof anyCause.name === "string" && anyCause.name.length > 0) summary.name = anyCause.name;
+    if (typeof anyCause.code === "string" && anyCause.code.length > 0) summary.code = anyCause.code;
+    if (typeof anyCause.hint === "string" && anyCause.hint.length > 0) summary.hint = anyCause.hint;
+  }
+  const stringifyResult = safeStringify(cause);
+  if (!stringifyResult.ok) {
+    return {
+      errorSummary: summary,
+      downgrade: "non_serializable"
+    };
+  }
+  if (truncated) {
+    return {
+      errorSummary: summary,
+      downgrade: "oversized"
+    };
+  }
+  if (message === "Unknown error") {
+    return {
+      errorSummary: summary,
+      downgrade: "unknown"
+    };
+  }
+  return { errorSummary: summary };
+};
+
+// src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = import_effect3.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect3.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect3.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect3.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect3.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect3.FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var browserLifecycleSeen = /* @__PURE__ */ new Set();
+var browserDiagnosticSeen = /* @__PURE__ */ new Set();
+var lifecycleErrorLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const causePretty = (() => {
+    try {
+      return import_effect3.Cause.pretty(event.cause, {
+        renderErrorCause: true
+      });
+    } catch {
+      try {
+        return JSON.stringify(event.cause, null, 2);
+      } catch {
+        return String(event.cause);
+      }
+    }
+  })();
+  const message = `[Logix][module=${moduleId}] lifecycle:error
+${causePretty}`;
+  return import_effect3.Effect.logError(message).pipe(
+    import_effect3.Effect.annotateLogs({
+      "logix.moduleId": moduleId,
+      "logix.event": "lifecycle:error",
+      "logix.cause": causePretty
+    })
+  );
+};
+var diagnosticLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`;
+  const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+  const msg = `${header}
+${detail}`;
+  const base = event.severity === "warning" ? import_effect3.Effect.logWarning(msg) : event.severity === "info" ? import_effect3.Effect.logInfo(msg) : import_effect3.Effect.logError(msg);
+  const annotations = {
+    "logix.moduleId": moduleId,
+    "logix.event": `diagnostic(${event.severity})`,
+    "logix.diagnostic.code": event.code,
+    "logix.diagnostic.message": event.message
+  };
+  if (event.hint) {
+    annotations["logix.diagnostic.hint"] = event.hint;
+  }
+  if (event.actionTag) {
+    annotations["logix.diagnostic.actionTag"] = event.actionTag;
+  }
+  return base.pipe(import_effect3.Effect.annotateLogs(annotations));
+};
+var noopLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, []);
+var errorOnlySink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void
+};
+var errorOnlyLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
+var consoleSink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event })
+};
+var consoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var renderBrowserConsoleEvent = (event) => {
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const moduleId = event.moduleId ?? "unknown";
+    const type = event.type;
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
+        "color:#6b7280;font-weight:bold",
+        // tag
+        "color:#3b82f6",
+        // label
+        "color:#9ca3af",
+        // module id
+        "color:#6b7280"
+        // type
+      );
+      console.log(event);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "lifecycle:error") {
+    const moduleId = event.moduleId ?? "unknown";
+    const causePretty = (() => {
+      try {
+        return import_effect3.Cause.pretty(event.cause, { renderErrorCause: true });
+      } catch {
+        try {
+          return JSON.stringify(event.cause, null, 2);
+        } catch {
+          return String(event.cause);
+        }
+      }
+    })();
+    const key = `${moduleId}|${causePretty}`;
+    if (browserLifecycleSeen.has(key)) {
+      return import_effect3.Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c lifecycle:error %c" + moduleId,
+        "color:#ef4444;font-weight:bold",
+        // tag
+        "color:#ef4444",
+        // label
+        "color:#9ca3af"
+        // module id
+      );
+      console.error(causePretty);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "diagnostic") {
+    const moduleId = event.moduleId ?? "unknown";
+    const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+    const color = event.severity === "warning" ? "color:#d97706" : event.severity === "info" ? "color:#3b82f6" : "color:#ef4444";
+    const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
+    const key = `${moduleId}|${event.code}|${event.message}`;
+    if (browserDiagnosticSeen.has(key)) {
+      return import_effect3.Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return import_effect3.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c " + label + "%c module=" + moduleId,
+        "color:#6b7280;font-weight:bold",
+        color,
+        "color:#9ca3af"
+      );
+      if (event.severity === "warning") {
+        console.warn(detail);
+      } else if (event.severity === "info") {
+        console.info(detail);
+      } else {
+        console.error(detail);
+      }
+      console.groupEnd();
+    });
+  }
+  return import_effect3.Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserDiagnosticConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void;
+    }
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect3.Effect.void;
+  }
+};
+var browserDiagnosticConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect3.Logger.replace(
+  import_effect3.Logger.defaultLogger,
+  import_effect3.Logger.prettyLogger({ mode: "browser", colors: true })
+);
+var record = (event) => import_effect3.Effect.gen(function* () {
+  const sinks = yield* import_effect3.FiberRef.get(currentDebugSinks);
+  if (isErrorOnlyOnlySinks(sinks)) {
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      if (event.severity !== "info") {
+        yield* diagnosticLog(event);
+      } else {
+        yield* import_effect3.Effect.void;
+      }
+      return;
+    }
+    yield* import_effect3.Effect.void;
+    return;
+  }
+  if (sinks.length === 0) {
+    if (isBrowser) {
+      if (event.type === "lifecycle:error" || event.type === "diagnostic") {
+        yield* renderBrowserConsoleEvent(event);
+        return;
+      }
+      yield* import_effect3.Effect.void;
+      return;
+    }
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* import_effect3.Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel = yield* import_effect3.FiberRef.get(currentDiagnosticsLevel);
+  let now;
+  const getNow = () => {
+    if (now === void 0) now = Date.now();
+    return now;
+  };
+  if (enriched.timestamp === void 0 && (diagnosticsLevel !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
+    ;
+    enriched.timestamp = getNow();
+  }
+  if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel = yield* import_effect3.FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect3.FiberRef.get(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const linkId = yield* import_effect3.FiberRef.get(currentLinkId);
+    if (linkId) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect3.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
+
+// src/internal/runtime/core/LogicUnitMeta.ts
+var LOGIC_UNIT_META = /* @__PURE__ */ Symbol.for("logix.module.logic.meta");
+var attachLogicUnitMeta = (logic, meta) => {
+  try {
+    Object.defineProperty(logic, LOGIC_UNIT_META, {
+      value: meta,
+      enumerable: false,
+      configurable: true
+    });
+  } catch {
+  }
+  return logic;
+};
+
+// src/internal/runtime/core/env.ts
+var import_effect8 = require("effect");
+
+// src/internal/runtime/core/HostScheduler.ts
+var noopCancel = () => {
+};
+var safeNowMs = () => {
+  const perf = globalThis.performance;
+  if (perf && typeof perf.now === "function") {
+    try {
+      const v = perf.now();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+    } catch {
+    }
+  }
+  return Date.now();
+};
+var safeQueueMicrotask = (cb) => {
+  const qm = globalThis.queueMicrotask;
+  if (typeof qm === "function") {
+    try {
+      qm(cb);
+      return;
+    } catch {
+    }
+  }
+  try {
+    Promise.resolve().then(cb);
+  } catch {
+    setTimeout(cb, 0);
+  }
+};
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
+};
+var makeMessageChannelMacrotask = () => {
+  const MC = globalThis.MessageChannel;
+  if (typeof MC !== "function") return void 0;
+  let channel;
+  try {
+    channel = new MC();
+  } catch {
+    return void 0;
+  }
+  const queue = [];
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    const tasks = queue.splice(0, queue.length);
+    for (const t of tasks) {
+      if (t.canceled) continue;
+      try {
+        t.cb();
+      } catch {
+      }
+    }
+  };
+  try {
+    channel.port1.onmessage = flush;
+  } catch {
+    return void 0;
+  }
+  const schedule = (cb) => {
+    const task = { canceled: false, cb };
+    queue.push(task);
+    if (!scheduled) {
+      scheduled = true;
+      try {
+        channel.port2.postMessage(void 0);
+      } catch {
+        scheduled = false;
+        return safeSetTimeout(0, cb);
+      }
+    }
+    return () => {
+      task.canceled = true;
+    };
+  };
+  return schedule;
+};
+var makeSetImmediateMacrotask = () => {
+  const si = globalThis.setImmediate;
+  const ci = globalThis.clearImmediate;
+  if (typeof si !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = si(cb);
+    } catch {
+      return safeSetTimeout(0, cb);
+    }
+    return () => {
+      if (typeof ci !== "function") return;
+      try {
+        ci(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeRaf = () => {
+  const raf = globalThis.requestAnimationFrame;
+  const cancel = globalThis.cancelAnimationFrame;
+  if (typeof raf !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = raf(cb);
+    } catch {
+      return noopCancel;
+    }
+    return () => {
+      if (typeof cancel !== "function") return;
+      try {
+        cancel(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeDefaultHostScheduler = () => {
+  const macrotask = makeSetImmediateMacrotask() ?? makeMessageChannelMacrotask() ?? ((cb) => safeSetTimeout(0, cb));
+  const raf = makeRaf();
+  return {
+    nowMs: safeNowMs,
+    scheduleMicrotask: safeQueueMicrotask,
+    scheduleMacrotask: macrotask,
+    scheduleAnimationFrame: (cb) => raf?.(cb) ?? macrotask(cb),
+    scheduleTimeout: safeSetTimeout
+  };
+};
+var globalHostScheduler;
+var getGlobalHostScheduler = () => {
+  globalHostScheduler ?? (globalHostScheduler = makeDefaultHostScheduler());
+  return globalHostScheduler;
+};
+
+// src/internal/runtime/core/RuntimeStore.ts
+var parseTopicKey = (topicKey) => {
+  const idx = topicKey.indexOf("::");
+  if (idx <= 0) return void 0;
+  const moduleId = topicKey.slice(0, idx);
+  const rest = topicKey.slice(idx + 2);
+  if (rest.length === 0) return void 0;
+  const idx2 = rest.indexOf("::");
+  if (idx2 < 0) {
+    return { kind: "module", moduleInstanceKey: `${moduleId}::${rest}` };
+  }
+  const instanceId = rest.slice(0, idx2);
+  const suffix = rest.slice(idx2 + 2);
+  if (suffix.startsWith("rq:")) {
+    const selectorId = suffix.slice("rq:".length);
+    if (selectorId.length === 0) return void 0;
+    return {
+      kind: "readQuery",
+      moduleInstanceKey: `${moduleId}::${instanceId}`,
+      selectorId
+    };
+  }
+  return { kind: "module", moduleInstanceKey: `${moduleId}::${instanceId}` };
+};
+var makeRuntimeStore = () => {
+  let tickSeq = 0;
+  const moduleStates = /* @__PURE__ */ new Map();
+  const topicVersions = /* @__PURE__ */ new Map();
+  const topicPriorities = /* @__PURE__ */ new Map();
+  const listenersByTopic = /* @__PURE__ */ new Map();
+  const subscriberCountByModule = /* @__PURE__ */ new Map();
+  const getTopicVersion = (topicKey) => topicVersions.get(topicKey) ?? 0;
+  const getTopicPriority = (topicKey) => topicPriorities.get(topicKey) ?? "normal";
+  const commitTopicBump = (topicKey, priority) => {
+    const prev = topicVersions.get(topicKey) ?? 0;
+    topicVersions.set(topicKey, prev + 1);
+    topicPriorities.set(topicKey, priority);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const set = existing ?? /* @__PURE__ */ new Set();
+    const alreadyHas = set.has(listener);
+    if (!alreadyHas) {
+      set.add(listener);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, set);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const current = listenersByTopic.get(topicKey);
+      if (!current) return;
+      const deleted = current.delete(listener);
+      if (deleted && info) {
+        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          subscriberCountByModule.delete(info.moduleInstanceKey);
+        } else {
+          subscriberCountByModule.set(info.moduleInstanceKey, next);
+        }
+      }
+      if (current.size === 0) {
+        listenersByTopic.delete(topicKey);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.size ?? 0;
+  const getModuleSubscriberCount = (moduleInstanceKey) => subscriberCountByModule.get(moduleInstanceKey) ?? 0;
+  const registerModuleInstance = (args) => {
+    moduleStates.set(args.moduleInstanceKey, args.initialState);
+    if (!topicVersions.has(args.moduleInstanceKey)) {
+      topicVersions.set(args.moduleInstanceKey, 0);
+      topicPriorities.set(args.moduleInstanceKey, "normal");
+    }
+  };
+  const unregisterModuleInstance = (moduleInstanceKey) => {
+    moduleStates.delete(moduleInstanceKey);
+  };
+  const commitTick = (args) => {
+    tickSeq = args.tickSeq;
+    for (const [key, commit] of args.accepted.modules) {
+      moduleStates.set(key, commit.state);
+    }
+    const changedTopics = /* @__PURE__ */ new Map();
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners = Array.from(listenersByTopic.get(topicKey) ?? []);
+      if (listeners.length > 0) {
+        changedTopics.set(topicKey, { priority, listeners });
+      }
+    }
+    return { changedTopics };
+  };
+  const getModuleState = (moduleInstanceKey) => moduleStates.get(moduleInstanceKey);
+  const dispose = () => {
+    moduleStates.clear();
+    topicVersions.clear();
+    topicPriorities.clear();
+    listenersByTopic.clear();
+    subscriberCountByModule.clear();
+  };
+  return {
+    getTickSeq: () => tickSeq,
+    getModuleState,
+    getTopicVersion,
+    getTopicPriority,
+    subscribeTopic,
+    getTopicSubscriberCount,
+    getModuleSubscriberCount,
+    registerModuleInstance,
+    unregisterModuleInstance,
+    commitTick,
+    dispose
+  };
+};
+
+// src/internal/runtime/core/TickScheduler.ts
+var import_effect6 = require("effect");
+
+// src/internal/runtime/core/DevtoolsHub.ts
+var import_effect4 = require("effect");
+var lastRunTs = 0;
+var lastRunTsSeq = 0;
+var nextRunId = () => {
+  const ts = Date.now();
+  if (ts === lastRunTs) {
+    lastRunTsSeq += 1;
+  } else {
+    lastRunTs = ts;
+    lastRunTsSeq = 0;
+  }
+  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
+};
+var currentRunId = nextRunId();
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect5 = require("effect");
+var inSyncTransactionFiber = import_effect5.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect5.FiberRef.unsafeMake(false);
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect7 = require("effect");
+var makeDeclarativeLinkRuntime = () => {
+  const moduleAsSourceById = /* @__PURE__ */ new Map();
+  const moduleAsSourceIdsBySource = /* @__PURE__ */ new Map();
+  const declarativeById = /* @__PURE__ */ new Map();
+  const declarativeReadNodesBySource = /* @__PURE__ */ new Map();
+  const registerModuleAsSourceLink = (link) => {
+    const stored = {
+      ...link,
+      hasValue: false,
+      lastValue: void 0
+    };
+    moduleAsSourceById.set(link.id, stored);
+    const set = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey) ?? /* @__PURE__ */ new Set();
+    set.add(link.id);
+    moduleAsSourceIdsBySource.set(link.sourceModuleInstanceKey, set);
+    return () => {
+      moduleAsSourceById.delete(link.id);
+      const current = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey);
+      if (!current) return;
+      current.delete(link.id);
+      if (current.size === 0) {
+        moduleAsSourceIdsBySource.delete(link.sourceModuleInstanceKey);
+      }
+    };
+  };
+  const registerDeclarativeLink = (link) => {
+    const readNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.readNodes) {
+      readNodeById.set(n.nodeId, n);
+    }
+    const dispatchNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.dispatchNodes) {
+      dispatchNodeById.set(n.nodeId, n);
+    }
+    const incomingByDispatch = /* @__PURE__ */ new Map();
+    for (const e of link.ir.edges) {
+      const to = e.to;
+      const isDispatch = dispatchNodeById.has(to);
+      if (!isDispatch) continue;
+      incomingByDispatch.set(to, (incomingByDispatch.get(to) ?? 0) + 1);
+      const count = incomingByDispatch.get(to) ?? 0;
+      if (count > 1) {
+        throw new Error(
+          `[DeclarativeLinkRuntime] Invalid DeclarativeLinkIR: dispatch node has multiple incoming edges (linkId=${link.linkId}, nodeId=${to}).`
+        );
+      }
+    }
+    const dispatchTargetsByReadNode = /* @__PURE__ */ new Map();
+    for (const e of link.ir.edges) {
+      const from = e.from;
+      const to = e.to;
+      if (!readNodeById.has(from)) continue;
+      if (!dispatchNodeById.has(to)) continue;
+      const list = dispatchTargetsByReadNode.get(from) ?? [];
+      list.push(to);
+      dispatchTargetsByReadNode.set(from, list);
+    }
+    const stored = {
+      ...link,
+      readNodeById,
+      dispatchNodeById,
+      dispatchTargetsByReadNode,
+      readNodeState: /* @__PURE__ */ new Map()
+    };
+    declarativeById.set(link.linkId, stored);
+    for (const n of link.readNodes) {
+      const list = declarativeReadNodesBySource.get(n.moduleInstanceKey) ?? [];
+      list.push({ linkId: link.linkId, nodeId: n.nodeId });
+      declarativeReadNodesBySource.set(n.moduleInstanceKey, list);
+    }
+    return () => {
+      declarativeById.delete(link.linkId);
+      for (const n of link.readNodes) {
+        const list = declarativeReadNodesBySource.get(n.moduleInstanceKey);
+        if (!list) continue;
+        const next = list.filter((x) => !(x.linkId === link.linkId && x.nodeId === n.nodeId));
+        if (next.length === 0) {
+          declarativeReadNodesBySource.delete(n.moduleInstanceKey);
+        } else {
+          declarativeReadNodesBySource.set(n.moduleInstanceKey, next);
+        }
+      }
+    };
+  };
+  const applyForSources = (args) => import_effect7.Effect.gen(function* () {
+    let scheduled = false;
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const ids = moduleAsSourceIdsBySource.get(sourceKey);
+      if (!ids || ids.size === 0) continue;
+      const commit = args.acceptedModules.get(sourceKey);
+      if (!commit) continue;
+      for (const id of ids) {
+        const link = moduleAsSourceById.get(id);
+        if (!link) continue;
+        let selected;
+        try {
+          selected = link.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const nextValue = link.computeValue(selected);
+        if (link.hasValue && link.equalsValue(link.lastValue, nextValue)) {
+          continue;
+        }
+        link.hasValue = true;
+        link.lastValue = nextValue;
+        scheduled = true;
+        yield* link.applyValue(nextValue);
+      }
+    }
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const refs = declarativeReadNodesBySource.get(sourceKey);
+      if (!refs || refs.length === 0) continue;
+      const commit = args.acceptedModules.get(sourceKey);
+      if (!commit) continue;
+      for (const ref of refs) {
+        const link = declarativeById.get(ref.linkId);
+        if (!link) continue;
+        const readNode = link.readNodeById.get(ref.nodeId);
+        if (!readNode) continue;
+        let value;
+        try {
+          value = readNode.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const state = link.readNodeState.get(ref.nodeId) ?? { hasValue: false, lastValue: void 0 };
+        const changed = !state.hasValue || !Object.is(state.lastValue, value);
+        if (!changed) continue;
+        state.hasValue = true;
+        state.lastValue = value;
+        link.readNodeState.set(ref.nodeId, state);
+        const targets = link.dispatchTargetsByReadNode.get(ref.nodeId) ?? [];
+        for (const dispatchNodeId of targets) {
+          const node = link.dispatchNodeById.get(dispatchNodeId);
+          if (!node) continue;
+          scheduled = true;
+          yield* node.dispatch(value);
+        }
+      }
+    }
+    return { scheduled };
+  });
+  return {
+    registerModuleAsSourceLink,
+    registerDeclarativeLink,
+    applyForSources
+  };
+};
+
+// src/internal/runtime/core/env.ts
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+var RuntimeStoreTag = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeStore")() {
+};
+var runtimeStoreLayer = import_effect8.Layer.scoped(
+  RuntimeStoreTag,
+  import_effect8.Effect.acquireRelease(
+    import_effect8.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect8.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect8.Context.Tag("@logixjs/core/HostScheduler")() {
+};
+var hostSchedulerLayer = import_effect8.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect8.Context.Tag("@logixjs/core/DeclarativeLinkRuntime")() {
+};
+var declarativeLinkRuntimeLayer = import_effect8.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect8.Context.Tag("@logixjs/core/TickScheduler")() {
+};
+
+// src/internal/runtime/core/TxnOriginOverride.ts
+var import_effect9 = require("effect");
+var currentTxnOriginOverride = import_effect9.FiberRef.unsafeMake(void 0);
+
+// src/internal/runtime/core/runtimeInternalsAccessor.ts
+var RUNTIME_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeInternals");
+var formatScope = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var getRuntimeInternals = (runtime) => {
+  const scope = runtime;
+  const internals = runtime[RUNTIME_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeInternals] Runtime internals not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make calls internalHooks.installInternalHooks (020 foundation).",
+      "- If you created a mock runtime for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Runtime internals not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== internals.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeInternals] Runtime internals instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `internals: ${formatScope(internals.moduleId, internals.instanceId)}`
+      ].join("\n") : "Runtime internals mismatch"
+    );
+  }
+  return internals;
+};
+
+// src/internal/runtime/core/RootContext.ts
+var import_effect10 = require("effect");
+var RootContextTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/RootContext")() {
+};
+var RootContextTag = RootContextTagImpl;
+
+// src/internal/effect-op.ts
+var import_effect12 = require("effect");
+
+// src/internal/observability/runSession.ts
+var import_effect11 = require("effect");
+var RunSessionTagImpl = class extends import_effect11.Context.Tag("@logixjs/core/RunSession")() {
+};
+var RunSessionTag = RunSessionTagImpl;
+
+// src/internal/effect-op.ts
+var nextGlobalOpSeq = 0;
+var nextOpSeq = () => {
+  nextGlobalOpSeq += 1;
+  return nextGlobalOpSeq;
+};
+var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
+var makeInRunSession = (params) => import_effect12.Effect.gen(function* () {
+  if (params.id) {
+    return {
+      id: params.id,
+      kind: params.kind,
+      name: params.name,
+      payload: params.payload,
+      meta: params.meta,
+      effect: params.effect
+    };
+  }
+  const meta = params.meta ?? {};
+  const instanceId = meta.instanceId;
+  let opSeq;
+  if (typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq)) {
+    opSeq = Math.floor(meta.opSeq);
+  } else {
+    const sessionOpt = yield* import_effect12.Effect.serviceOption(RunSessionTag);
+    if (import_effect12.Option.isSome(sessionOpt)) {
+      const key = instanceId ?? "global";
+      opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
+    } else {
+      opSeq = nextOpSeq();
+    }
+  }
+  return {
+    id: makeId(instanceId, opSeq),
+    kind: params.kind,
+    name: params.name,
+    payload: params.payload,
+    meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },
+    effect: params.effect
+  };
+});
+var run = (op, stack) => runWithMiddleware(op, stack);
+
+// src/internal/runtime/core/WorkflowRuntime.ts
+var WORKFLOW_REGISTRY = /* @__PURE__ */ Symbol.for("@logixjs/core/workflowRegistry");
+var isRecord3 = (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 asNonEmptyString3 = (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) => import_effect13.Effect.gen(function* () {
+      const fieldPath = asNonEmptyString3(isRecord3(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 = isRecord3(input) && input.force === true;
+      const runHandler = (state) => force ? import_effect13.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
+      const inTxn = yield* import_effect13.FiberRef.get(inSyncTransactionFiber);
+      if (inTxn) {
+        const state = yield* runtime.getState;
+        yield* runHandler(state);
+        return;
+      }
+      yield* internals.txn.runWithStateTransaction(
+        {
+          kind: "source-refresh",
+          name: fieldPath
+        },
+        () => import_effect13.Effect.gen(function* () {
+          const state = yield* runtime.getState;
+          yield* runHandler(state);
+        })
+      );
+    });
+  }
+  const tag = import_effect13.Context.GenericTag(serviceId);
+  const opt = import_effect13.Context.getOption(env, tag);
+  if (import_effect13.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 call2 = callFn;
+    return (input) => call2.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) => import_effect13.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) => import_effect13.Effect.async((resume) => {
+  let fired = false;
+  const cancel = args.host.scheduleTimeout(args.ms, () => {
+    fired = true;
+    args.host.scheduleMicrotask(() => resume(import_effect13.Effect.void));
+  });
+  return import_effect13.Effect.sync(() => {
+    cancel();
+  }).pipe(import_effect13.Effect.zipRight(fired ? import_effect13.Effect.void : args.onCancel));
+});
+var ensureLimiterReady = (registry, runtime) => import_effect13.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* import_effect13.Effect.makeSemaphore(n);
+});
+var withRootEnvIfAvailable = (eff) => import_effect13.Effect.gen(function* () {
+  const rootOpt = yield* import_effect13.Effect.serviceOption(RootContextTag);
+  if (import_effect13.Option.isNone(rootOpt)) {
+    return yield* eff;
+  }
+  const root = rootOpt.value;
+  const rootEnv = root.context ?? (yield* import_effect13.Deferred.await(root.ready));
+  const currentEnv = yield* import_effect13.Effect.context();
+  const mergedEnv = import_effect13.Context.merge(rootEnv, currentEnv);
+  return yield* import_effect13.Effect.provide(eff, mergedEnv);
+});
+var ensurePortsResolved = (registry, runtime) => import_effect13.Effect.gen(function* () {
+  const done = yield* import_effect13.Deferred.isDone(registry.portsReady);
+  if (done) {
+    yield* import_effect13.Deferred.await(registry.portsReady);
+    return;
+  }
+  if (registry.portsResolving) {
+    yield* import_effect13.Deferred.await(registry.portsReady);
+    return;
+  }
+  registry.portsResolving = true;
+  const env = yield* import_effect13.Effect.context();
+  yield* import_effect13.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(
+    import_effect13.Effect.tap(() => import_effect13.Deferred.succeed(registry.portsReady, void 0)),
+    import_effect13.Effect.catchAllCause((cause) => import_effect13.Deferred.failCause(registry.portsReady, cause).pipe(import_effect13.Effect.zipRight(import_effect13.Effect.failCause(cause)))),
+    import_effect13.Effect.ensuring(
+      import_effect13.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) => import_effect13.Effect.gen(function* () {
+  const { entry, runtime, registry } = args;
+  const { program, state } = entry;
+  const diagnostics = yield* import_effect13.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: import_effect13.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* import_effect13.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: import_effect13.Effect.void,
+          middleware: args.middleware
+        });
+      }
+    }
+    state.currentRunId = runId;
+  }
+  const observe = shouldObserveForRun(diagnostics, runSeq);
+  const policy = { disableObservers: !observe };
+  const programEffect = import_effect13.Effect.gen(function* () {
+    const host = yield* HostSchedulerTag;
+    const tick = yield* TickSchedulerTag;
+    if (!program.steps) {
+      const env = yield* import_effect13.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) => import_effect13.Effect.gen(function* () {
+      for (const step of steps) {
+        if (!canWriteBack()) return;
+        if (step.kind === "dispatch") {
+          const payload2 = evalPayload(step.payload);
+          const action = { _tag: step.actionTag, payload: payload2 };
+          const tickSeq = getTickSeq();
+          const dispatchEffectBase = program.priority === "nonUrgent" ? runtime.dispatchLowPriority(action) : runtime.dispatch(action);
+          const dispatchEffect = timerTriggered ? import_effect13.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(import_effect13.Effect.asVoid);
+          continue;
+        }
+        if (step.kind === "delay") {
+          const timerId = emitTimerEvents ? `${runId}::timer:${step.key}` : void 0;
+          const recordTimerEvent = (name, patchMeta) => import_effect13.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: import_effect13.Effect.void,
+              middleware: args.middleware
+            });
+          });
+          const schedule = emitTimerEvents ? recordTimerEvent("workflow.timer.schedule") : import_effect13.Effect.void;
+          const onCancel = emitTimerEvents ? recordTimerEvent("workflow.timer.cancel", { reason: "interrupt" }) : import_effect13.Effect.void;
+          const fired = emitTimerEvents ? recordTimerEvent("workflow.timer.fired") : import_effect13.Effect.void;
+          const delayEffect = schedule.pipe(
+            import_effect13.Effect.zipRight(makeTimer({ host, ms: step.ms, onCancel })),
+            import_effect13.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(import_effect13.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 : import_effect13.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) => import_effect13.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: import_effect13.Effect.void,
+                middleware: args.middleware
+              });
+            });
+            const schedule = emitTimerEvents ? recordTimeoutEvent("workflow.timeout.schedule") : import_effect13.Effect.void;
+            const onCancel = emitTimerEvents ? recordTimeoutEvent("workflow.timeout.cancel", { reason: "interrupt" }) : import_effect13.Effect.void;
+            const fired = emitTimerEvents ? recordTimeoutEvent("workflow.timeout.fired") : import_effect13.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(
+              import_effect13.Effect.zipRight(makeTimer({ host, ms: timeoutMs, onCancel })),
+              import_effect13.Effect.zipRight(fired),
+              import_effect13.Effect.zipRight(import_effect13.Effect.fail(timeoutError))
+            );
+            return yield* import_effect13.Effect.raceFirst(base, timeoutFail);
+          });
+          const attemptExit = yield* import_effect13.Effect.exit(withTimeout);
+          exit = attemptExit;
+          if (!canWriteBack() || import_effect13.Exit.isSuccess(attemptExit)) {
+            break;
+          }
+          if (import_effect13.Cause.isInterrupted(attemptExit.cause) || import_effect13.Option.isNone(import_effect13.Cause.failureOption(attemptExit.cause))) {
+            break;
+          }
+          if (attempt < maxRetries + 1) {
+            continue;
+          }
+          break;
+        }
+        if (!exit) {
+          exit = import_effect13.Exit.succeed(void 0);
+        }
+        if (!canWriteBack()) return;
+        if (import_effect13.Exit.isSuccess(exit)) {
+          yield* runSteps(step.onSuccess);
+        } else {
+          const failure = import_effect13.Option.getOrUndefined(import_effect13.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(import_effect13.Effect.asVoid);
+  });
+  const limited = registry.parallelLimiter ? registry.parallelLimiter.withPermits(1)(programEffect) : programEffect;
+  const fiber = yield* import_effect13.Effect.forkScoped(
+    limited.pipe(
+      import_effect13.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(import_effect13.Effect.catchAllCause(() => import_effect13.Effect.void));
+      }),
+      import_effect13.Effect.ensuring(
+        import_effect13.Effect.sync(() => {
+          if (state.mode === "exhaust") {
+            state.busy = false;
+          }
+        })
+      )
+    )
+  );
+  if (state.mode === "latest") {
+    state.current = fiber;
+  }
+});
+var ensureRegistry = (runtime) => import_effect13.Effect.gen(function* () {
+  const existing = getRegistry(runtime);
+  if (existing) {
+    return {
+      moduleId: runtime.moduleId,
+      instanceId: runtime.instanceId,
+      registry: existing
+    };
+  }
+  const portsReady = yield* import_effect13.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) => import_effect13.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 = asNonEmptyString3(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(
+            import_effect13.Effect.gen(function* () {
+              const middlewareOpt = yield* import_effect13.Effect.serviceOption(EffectOpMiddlewareTag);
+              const middleware = import_effect13.Option.isSome(middlewareOpt) ? middlewareOpt.value : void 0;
+              yield* ensurePortsResolved(registry, runtime).pipe(import_effect13.Effect.orDie);
+              yield* startProgramRun({
+                entry,
+                runtime,
+                registry,
+                trigger: { kind: "lifecycle", phase: "onStart" },
+                payload: void 0,
+                middleware
+              });
+            })
+          ),
+          { name: `workflow:${localId}` }
+        );
+      } else {
+        internals.lifecycle.registerInitRequired(
+          import_effect13.Effect.gen(function* () {
+            const middlewareOpt = yield* import_effect13.Effect.serviceOption(EffectOpMiddlewareTag);
+            const middleware = import_effect13.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) => import_effect13.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* import_effect13.Effect.serviceOption(EffectOpMiddlewareTag);
+  const middleware = import_effect13.Option.isSome(middlewareOpt) ? middlewareOpt.value : void 0;
+  const actions$ = runtime.actions$;
+  const portsExit = yield* import_effect13.Effect.exit(ensurePortsResolved(registry, runtime));
+  if (import_effect13.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* import_effect13.Stream.runForEach(
+    actions$,
+    (action) => import_effect13.Effect.gen(function* () {
+      const actionTag = resolveActionTag(action);
+      if (!actionTag) return;
+      const entries = registry.byActionTag.get(actionTag);
+      if (!entries || entries.length === 0) return;
+      const payload2 = isRecord3(action) ? action.payload : void 0;
+      yield* import_effect13.Effect.forEach(
+        entries,
+        (entry) => startProgramRun({
+          entry,
+          runtime,
+          registry,
+          trigger: { kind: "action", actionTag },
+          payload: payload2,
+          middleware
+        }),
+        { discard: true }
+      );
+    })
+  ).pipe(
+    import_effect13.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 installOne = (args) => {
+  const localId = asNonEmptyString3(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;
+};
+
+// src/Workflow.ts
+var KernelSourceRefreshPortTagImpl = class extends import_effect14.Context.Tag("logix/kernel/sourceRefresh")() {
+};
+var KernelPorts = {
+  sourceRefresh: KernelSourceRefreshPortTagImpl
+};
+var forModule = (_module) => {
+  return {
+    onAction: (actionTag) => onAction(actionTag),
+    onStart,
+    onInit,
+    payload,
+    payloadPath,
+    constValue,
+    object,
+    merge,
+    dispatch: (args) => dispatch(args),
+    delay,
+    callById: (args) => callById(args),
+    call: (args) => call(args),
+    fragment: (fragmentId, steps) => fragment(fragmentId, steps),
+    withPolicy: (patch, part) => withPolicy(patch, part),
+    compose: (...parts) => compose(...parts),
+    make: (input) => make(input),
+    fromJSON: (def) => fromJSON(def)
+  };
+};
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isReadonlyArray = (value) => Array.isArray(value);
+var asNonEmptyString4 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var mergePolicy = (base, patch) => {
+  if (!base && !patch) return void 0;
+  return {
+    ...base ?? {},
+    ...patch ?? {}
+  };
+};
+var applyCallDefaults = (steps, patch) => {
+  const timeoutMsDefault = patch.timeoutMs;
+  const retryDefault = patch.retry;
+  const visit = (step) => {
+    if (step.kind !== "call") return step;
+    let changed = false;
+    const timeoutMs = step.timeoutMs ?? timeoutMsDefault;
+    if (timeoutMs !== step.timeoutMs) changed = true;
+    const retry = step.retry ?? retryDefault;
+    if (retry !== step.retry) changed = true;
+    const onSuccess = step.onSuccess.map(visit);
+    const onFailure = step.onFailure.map(visit);
+    if (onSuccess !== step.onSuccess) changed = true;
+    if (onFailure !== step.onFailure) changed = true;
+    if (!changed) return step;
+    return {
+      ...step,
+      ...timeoutMs !== void 0 ? { timeoutMs } : null,
+      ...retry !== void 0 ? { retry } : null,
+      onSuccess,
+      onFailure
+    };
+  };
+  return steps.map(visit);
+};
+var resolveStepsInput = (input) => {
+  if (Array.isArray(input)) {
+    return { steps: input };
+  }
+  if (isRecord4(input) && Array.isArray(input.steps)) {
+    return input;
+  }
+  throw makeWorkflowError({
+    code: "WORKFLOW_INVALID_DEF",
+    message: 'Workflow.make: "steps" must be an array or a { steps, sources?, policy? } object.',
+    detail: { steps: input }
+  });
+};
+var recordSourcesForFragment = (sources, fragmentId, step) => {
+  sources[step.key] = { fragmentId };
+  if (step.kind !== "call") return;
+  for (const inner of step.onSuccess) recordSourcesForFragment(sources, fragmentId, inner);
+  for (const inner of step.onFailure) recordSourcesForFragment(sources, fragmentId, inner);
+};
+var onAction = (actionTag) => ({
+  kind: "action",
+  actionTag
+});
+var onStart = () => ({
+  kind: "lifecycle",
+  phase: "onStart"
+});
+var onInit = () => ({
+  kind: "lifecycle",
+  phase: "onInit"
+});
+var payload = () => ({ kind: "payload" });
+var payloadPath = (pointer) => ({ kind: "payload.path", pointer });
+var constValue = (value) => ({ kind: "const", value });
+var object = (fields) => ({ kind: "object", fields });
+var merge = (items) => ({ kind: "merge", items });
+var dispatch = (args) => ({
+  kind: "dispatch",
+  key: args.key,
+  actionTag: args.actionTag,
+  ...args.payload ? { payload: args.payload } : null
+});
+var delay = (args) => ({
+  kind: "delay",
+  key: args.key,
+  ms: args.ms
+});
+var callById = (args) => ({
+  kind: "call",
+  key: args.key,
+  serviceId: args.serviceId,
+  ...args.input ? { input: args.input } : null,
+  ...args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : null,
+  ...args.retry ? { retry: args.retry } : null,
+  onSuccess: args.onSuccess ?? [],
+  onFailure: args.onFailure ?? []
+});
+var call = (args) => {
+  const serviceId = fromTag(args.service);
+  if (!serviceId) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_SERVICE_ID",
+      message: "call(service): serviceId derived from tag must be a non-empty string (see 078 ServiceId contract).",
+      detail: { tag: String(args.service) }
+    });
+  }
+  return callById({
+    ...args,
+    serviceId
+  });
+};
+var fragment = (fragmentId, steps) => ({
+  fragmentId,
+  steps
+});
+var withPolicy = (patch, part) => {
+  let normalized;
+  if (isReadonlyArray(part)) {
+    normalized = { steps: part };
+  } else {
+    const partUnknown = part;
+    if (!isRecord4(partUnknown) || !isReadonlyArray(partUnknown.steps)) {
+      throw makeWorkflowError({
+        code: "WORKFLOW_INVALID_DEF",
+        message: "withPolicy: invalid workflow part (expected steps[] / fragment / composeResult).",
+        detail: { part }
+      });
+    }
+    normalized = {
+      steps: part.steps,
+      ...part.sources ? { sources: part.sources } : null,
+      ...part.policy ? { policy: part.policy } : null
+    };
+  }
+  const steps = applyCallDefaults(normalized.steps, patch);
+  const patchPolicy = (() => {
+    const concurrency = patch.concurrency;
+    const priority = patch.priority;
+    return concurrency !== void 0 || priority !== void 0 ? { concurrency, priority } : void 0;
+  })();
+  const nextPolicy = mergePolicy(patchPolicy, normalized.policy);
+  return {
+    steps,
+    ...normalized.sources ? { sources: normalized.sources } : null,
+    ...nextPolicy ? { policy: nextPolicy } : null
+  };
+};
+var compose = (...parts) => {
+  const steps = [];
+  const sources = {};
+  let policy = void 0;
+  const ownersByKey = /* @__PURE__ */ new Map();
+  const recordOwner = (stepKey, fragmentId) => {
+    const list = ownersByKey.get(stepKey) ?? [];
+    list.push({ stepKey, ...fragmentId ? { fragmentId } : null });
+    ownersByKey.set(stepKey, list);
+  };
+  const recordOwners = (step, resolveFragmentId) => {
+    recordOwner(step.key, resolveFragmentId(step.key));
+    if (step.kind !== "call") return;
+    for (const inner of step.onSuccess) recordOwners(inner, resolveFragmentId);
+    for (const inner of step.onFailure) recordOwners(inner, resolveFragmentId);
+  };
+  for (const part of parts) {
+    if (isReadonlyArray(part)) {
+      steps.push(...part);
+      for (const step of part) recordOwners(step, () => void 0);
+      continue;
+    }
+    const partSteps = part.steps;
+    steps.push(...partSteps);
+    const partSources = part.sources;
+    if (partSources && typeof partSources === "object") {
+      for (const k of Object.keys(partSources).sort()) {
+        sources[k] = { ...partSources[k] };
+      }
+    }
+    const fragmentId = "fragmentId" in part ? part.fragmentId : void 0;
+    if (typeof fragmentId === "string" && fragmentId.length > 0) {
+      for (const step of partSteps) {
+        recordSourcesForFragment(sources, fragmentId, step);
+      }
+    }
+    const resolveFragmentIdForPart = (stepKey) => {
+      if (typeof fragmentId === "string" && fragmentId.length > 0) return fragmentId;
+      const fromSources = partSources?.[stepKey]?.fragmentId;
+      return typeof fromSources === "string" && fromSources.length > 0 ? fromSources : void 0;
+    };
+    for (const step of partSteps) recordOwners(step, resolveFragmentIdForPart);
+    policy = mergePolicy(policy, part.policy);
+  }
+  const finalSources = Object.keys(sources).length > 0 ? sources : void 0;
+  const duplicateKeys = Array.from(ownersByKey.entries()).filter(([, owners]) => owners.length > 1).map(([k]) => k).sort();
+  if (duplicateKeys.length > 0) {
+    const k = duplicateKeys[0];
+    throw makeWorkflowError({
+      code: "WORKFLOW_DUPLICATE_STEP_KEY",
+      message: `Duplicate stepKey "${k}" detected during composition.`,
+      source: { stepKey: k },
+      detail: { duplicateKey: k, owners: ownersByKey.get(k) ?? [] }
+    });
+  }
+  return {
+    steps,
+    ...finalSources ? { sources: finalSources } : null,
+    ...policy ? { policy } : null
+  };
+};
+var make = (input) => {
+  const localId = asNonEmptyString4(input.localId);
+  if (!localId) {
+    throw makeWorkflowError({
+      code: "WORKFLOW_INVALID_DEF",
+      message: "Workflow.make: localId must be a non-empty string.",
+      detail: { localId: input.localId }
+    });
+  }
+  const stepsInput = resolveStepsInput(input.steps);
+  const merged = mergePolicy(input.policy, stepsInput.policy);
+  const def = normalizeWorkflowDefV1({
+    astVersion: 1,
+    localId,
+    trigger: input.trigger,
+    ...merged ? { policy: merged } : null,
+    steps: stepsInput.steps,
+    ...stepsInput.sources ? { sources: stepsInput.sources } : null,
+    ...input.meta ? { meta: input.meta } : null
+  });
+  const staticIrCache = /* @__PURE__ */ new Map();
+  return {
+    _tag: "Workflow",
+    def,
+    toJSON: () => def,
+    validate: () => validateWorkflowDefV1(def),
+    exportStaticIr: (moduleId) => {
+      const cached = staticIrCache.get(moduleId);
+      if (cached) return cached;
+      const ir = compileWorkflowStaticIrV1({ moduleId, def });
+      staticIrCache.set(moduleId, ir);
+      return ir;
+    },
+    install: (moduleTag) => installOne({
+      moduleTag,
+      program: { _tag: "Workflow", def }
+    })
+  };
+};
+var fromJSON = (def) => make({
+  localId: def.localId,
+  trigger: def.trigger,
+  ...def.policy ? { policy: def.policy } : null,
+  steps: {
+    steps: def.steps,
+    ...def.sources ? { sources: def.sources } : null
+  },
+  ...def.meta ? { meta: def.meta } : null
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KernelPorts,
+  call,
+  callById,
+  compose,
+  constValue,
+  delay,
+  dispatch,
+  forModule,
+  fragment,
+  fromJSON,
+  make,
+  merge,
+  object,
+  onAction,
+  onInit,
+  onStart,
+  payload,
+  payloadPath,
+  withPolicy
+});
+//# sourceMappingURL=Workflow.cjs.map