@logixjs/core 0.0.1 → 1.0.0

package/dist/chunk-S4S5N4BJ.js

@@ -0,0 +1,1461 @@
+import {
+  getGlobalHostScheduler
+} from "./chunk-MYKNINNN.js";
+import {
+  currentDiagnosticsLevel,
+  currentTraceMode,
+  record,
+  runByMode
+} from "./chunk-V2SBGVDO.js";
+
+// src/internal/runtime/core/TickScheduler.ts
+import { Effect as Effect4 } from "effect";
+
+// src/internal/runtime/core/JobQueue.ts
+var maxPriority = (a, b) => a === "normal" || b === "normal" ? "normal" : "low";
+var makeJobQueue = () => {
+  let pendingModules = /* @__PURE__ */ new Map();
+  let pendingDirtyTopics = /* @__PURE__ */ new Map();
+  const hasPending = () => pendingModules.size > 0 || pendingDirtyTopics.size > 0;
+  const enqueueModuleCommit = (commit) => {
+    const prev = pendingModules.get(commit.moduleInstanceKey);
+    if (!prev) {
+      pendingModules.set(commit.moduleInstanceKey, commit);
+      return false;
+    }
+    pendingModules.set(commit.moduleInstanceKey, {
+      ...commit,
+      meta: {
+        ...commit.meta,
+        priority: maxPriority(prev.meta.priority, commit.meta.priority)
+      }
+    });
+    return true;
+  };
+  const markTopicDirty = (topicKey, priority) => {
+    const prev = pendingDirtyTopics.get(topicKey);
+    pendingDirtyTopics.set(topicKey, prev ? maxPriority(prev, priority) : priority);
+    return prev != null;
+  };
+  const drain = () => {
+    if (!hasPending()) return void 0;
+    const drained = {
+      modules: pendingModules,
+      dirtyTopics: pendingDirtyTopics
+    };
+    pendingModules = /* @__PURE__ */ new Map();
+    pendingDirtyTopics = /* @__PURE__ */ new Map();
+    return drained;
+  };
+  const requeue = (drain2) => {
+    for (const [, commit] of drain2.modules) {
+      enqueueModuleCommit(commit);
+    }
+    for (const [k, p] of drain2.dirtyTopics) {
+      markTopicDirty(k, p);
+    }
+  };
+  return {
+    hasPending,
+    enqueueModuleCommit,
+    markTopicDirty,
+    drain,
+    requeue
+  };
+};
+
+// src/internal/runtime/core/TaskRunner.ts
+import { Cause, Effect as Effect3, ServiceMap as ServiceMap2 } from "effect";
+
+// src/internal/runtime/core/env.ts
+import { Effect as Effect2, Layer, ServiceMap } from "effect";
+
+// src/internal/runtime/core/RuntimeStore.ts
+var makeModuleInstanceKey = (moduleId, instanceId) => `${moduleId}::${instanceId}`;
+var makeReadQueryTopicKey = (moduleInstanceKey, selectorId) => `${moduleInstanceKey}::rq:${selectorId}`;
+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 EMPTY_LISTENER_SNAPSHOT = [];
+var NO_CHANGED_TOPIC_LISTENERS = [];
+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 refreshTopicSnapshot = (state) => {
+    state.snapshot = Array.from(state.listeners);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const state = existing ?? { listeners: /* @__PURE__ */ new Set(), snapshot: EMPTY_LISTENER_SNAPSHOT };
+    const alreadyHas = state.listeners.has(listener);
+    if (!alreadyHas) {
+      state.listeners.add(listener);
+      refreshTopicSnapshot(state);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, state);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const currentState = listenersByTopic.get(topicKey);
+      if (!currentState) return;
+      const deleted = currentState.listeners.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 (currentState.listeners.size === 0) {
+        listenersByTopic.delete(topicKey);
+      } else if (deleted) {
+        refreshTopicSnapshot(currentState);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.listeners.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);
+    }
+    if (args.accepted.dirtyTopics.size === 0) {
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    if (args.onListener) {
+      let firstTopicListeners;
+      let secondTopicListeners;
+      let restTopicListeners;
+      for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+        commitTopicBump(topicKey, priority);
+        const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+        if (listeners.length === 0) {
+          continue;
+        }
+        if (!firstTopicListeners) {
+          firstTopicListeners = listeners;
+          continue;
+        }
+        if (!secondTopicListeners) {
+          secondTopicListeners = listeners;
+          continue;
+        }
+        if (!restTopicListeners) {
+          restTopicListeners = [];
+        }
+        restTopicListeners.push(listeners);
+      }
+      if (firstTopicListeners) {
+        for (const listener of firstTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (secondTopicListeners) {
+        for (const listener of secondTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (restTopicListeners) {
+        for (const listeners of restTopicListeners) {
+          for (const listener of listeners) {
+            try {
+              args.onListener(listener);
+            } catch {
+            }
+          }
+        }
+      }
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    let singleTopicListeners;
+    let flattenedTopicListeners;
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+      if (listeners.length === 0) {
+        continue;
+      }
+      if (flattenedTopicListeners) {
+        for (const listener of listeners) {
+          flattenedTopicListeners.push(listener);
+        }
+        continue;
+      }
+      if (!singleTopicListeners) {
+        singleTopicListeners = listeners;
+        continue;
+      }
+      flattenedTopicListeners = Array.from(singleTopicListeners);
+      for (const listener of listeners) {
+        flattenedTopicListeners.push(listener);
+      }
+    }
+    return {
+      changedTopicListeners: flattenedTopicListeners ?? singleTopicListeners ?? NO_CHANGED_TOPIC_LISTENERS
+    };
+  };
+  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/DeclarativeLinkRuntime.ts
+import { Effect } from "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) => 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 getDefaultStateTxnInstrumentation = () => isDevEnv() ? "full" : "light";
+var StateTransactionConfigTagImpl = class extends ServiceMap.Service()("@logixjs/core/StateTransactionRuntimeConfig") {
+};
+var StateTransactionConfigTag = StateTransactionConfigTagImpl;
+var ReadQueryStrictGateConfigTagImpl = class extends ServiceMap.Service()("@logixjs/core/ReadQueryStrictGateRuntimeConfig") {
+};
+var ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl;
+var ReplayModeConfigTagImpl = class extends ServiceMap.Service()("@logixjs/core/ReplayModeConfig") {
+};
+var ReplayModeConfigTag = ReplayModeConfigTagImpl;
+var StateTransactionOverridesTagImpl = class extends ServiceMap.Service()("@logixjs/core/StateTransactionOverrides") {
+};
+var StateTransactionOverridesTag = StateTransactionOverridesTagImpl;
+var SchedulingPolicySurfaceTagImpl = class extends ServiceMap.Service()("@logixjs/core/SchedulingPolicySurface") {
+};
+var SchedulingPolicySurfaceTag = SchedulingPolicySurfaceTagImpl;
+var SchedulingPolicySurfaceOverridesTagImpl = class extends ServiceMap.Service()("@logixjs/core/SchedulingPolicySurfaceOverrides") {
+};
+var SchedulingPolicySurfaceOverridesTag = SchedulingPolicySurfaceOverridesTagImpl;
+var ConcurrencyPolicyTag = SchedulingPolicySurfaceTag;
+var RuntimeStoreTag = class extends ServiceMap.Service()("@logixjs/core/RuntimeStore") {
+};
+var runtimeStoreLayer = Layer.effect(
+  RuntimeStoreTag,
+  Effect2.acquireRelease(
+    Effect2.sync(() => makeRuntimeStore()),
+    (store) => Effect2.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends ServiceMap.Service()("@logixjs/core/HostScheduler") {
+};
+var hostSchedulerLayer = Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var hostSchedulerTestStubLayer = (scheduler) => Layer.succeed(HostSchedulerTag, scheduler);
+var DeclarativeLinkRuntimeTag = class extends ServiceMap.Service()("@logixjs/core/DeclarativeLinkRuntime") {
+};
+var declarativeLinkRuntimeLayer = Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends ServiceMap.Service()("@logixjs/core/TickScheduler") {
+};
+var tickSchedulerLayer = (config) => Layer.effect(
+  TickSchedulerTag,
+  Effect2.gen(function* () {
+    const store = yield* Effect2.service(RuntimeStoreTag).pipe(Effect2.orDie);
+    const declarativeLinkRuntime = yield* Effect2.service(DeclarativeLinkRuntimeTag).pipe(Effect2.orDie);
+    const hostScheduler = yield* Effect2.service(HostSchedulerTag).pipe(Effect2.orDie);
+    return makeTickScheduler({ runtimeStore: store, declarativeLinkRuntime, hostScheduler, config });
+  })
+);
+
+// src/internal/runtime/core/TaskRunner.ts
+var inSyncTransactionFiber = ServiceMap2.Reference("@logixjs/core/TaskRunner.inSyncTransactionFiber", {
+  defaultValue: () => false
+});
+var forceSourceRefresh = ServiceMap2.Reference("@logixjs/core/TaskRunner.forceSourceRefresh", {
+  defaultValue: () => false
+});
+var inSyncTransactionShadowDepth = 0;
+var enterSyncTransactionShadow = () => {
+  inSyncTransactionShadowDepth += 1;
+};
+var exitSyncTransactionShadow = () => {
+  inSyncTransactionShadowDepth = Math.max(0, inSyncTransactionShadowDepth - 1);
+};
+var isInSyncTransactionShadow = () => inSyncTransactionShadowDepth > 0;
+var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var defaultOrigins = (triggerName) => ({
+  pending: {
+    kind: "task:pending",
+    name: triggerName
+  },
+  success: {
+    kind: "service-callback",
+    name: "task:success"
+  },
+  failure: {
+    kind: "service-callback",
+    name: "task:failure"
+  }
+});
+var shouldNoopInSyncTransactionFiber = (options) => Effect3.gen(function* () {
+  const inTxn = yield* Effect3.service(inSyncTransactionFiber);
+  if (!inTxn) {
+    return false;
+  }
+  if (isDevEnv()) {
+    yield* record({
+      type: "diagnostic",
+      moduleId: options.moduleId,
+      instanceId: options.instanceId,
+      code: options.code,
+      severity: options.severity,
+      message: options.message,
+      hint: options.hint,
+      actionTag: options.actionTag,
+      kind: options.kind
+    });
+  }
+  return true;
+});
+var resolveConcurrencyLimit = (runtime) => runtime.resolveConcurrencyPolicy ? runtime.resolveConcurrencyPolicy().pipe(Effect3.map((p) => p.concurrencyLimit)) : Effect3.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => Effect3.gen(function* () {
+  const noop = yield* shouldNoopInSyncTransactionFiber({
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "logic::invalid_usage",
+    severity: "error",
+    message: "run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
+    hint: "Call run*Task from the run section of a watcher (e.g. $.onAction/$.onState/$.on); do not call it directly inside a reducer / trait.run / synchronous transaction body. For long-lived flows, use a multi-entry pattern (pending \u2192 IO \u2192 writeback).",
+    kind: "run_task_in_transaction"
+  });
+  if (noop) {
+    return;
+  }
+  const defaults = defaultOrigins(config.triggerName);
+  const origins = {
+    pending: config.origin?.pending ?? defaults.pending,
+    success: config.origin?.success ?? defaults.success,
+    failure: config.origin?.failure ?? defaults.failure
+  };
+  const pending = config.pending;
+  if (pending) {
+    yield* Effect3.uninterruptible(
+      runtime.runWithStateTransaction(origins.pending, () => Effect3.asVoid(resolve(pending, payload)))
+    );
+  }
+  const io = resolve(config.effect, payload);
+  const exit = yield* Effect3.exit(io);
+  if (getCanWriteBack) {
+    const ok = yield* getCanWriteBack;
+    if (!ok) {
+      return;
+    }
+  }
+  if (exit._tag === "Success") {
+    const success = config.success;
+    if (success) {
+      yield* runtime.runWithStateTransaction(origins.success, () => Effect3.asVoid(success(exit.value, payload)));
+    }
+    return;
+  }
+  const cause = exit.cause;
+  if (Cause.hasInterruptsOnly(cause)) {
+    return;
+  }
+  const failure = config.failure;
+  if (failure) {
+    yield* runtime.runWithStateTransaction(origins.failure, () => Effect3.asVoid(failure(cause, payload)));
+  }
+}).pipe(
+  // Watchers must not crash as a whole due to a single task failure: swallow errors, but keep them diagnosable.
+  Effect3.catchCause((cause) => record({
+    type: "diagnostic",
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "task_runner::unhandled_failure",
+    severity: "error",
+    message: "TaskRunner encountered an unhandled failure (pending/IO/writeback).",
+    hint: "Add a failure writeback for this task or handle errors explicitly upstream; avoid fire-and-forget swallowing errors.",
+    actionTag: config.triggerName,
+    kind: "task_runner_unhandled_failure",
+    trigger: {
+      kind: "task",
+      name: config.triggerName
+    }
+  }).pipe(Effect3.flatMap(() => Effect3.logError("TaskRunner error", cause))))
+);
+var runTask = (args) => {
+  const mode = args.mode ?? "task";
+  const runtime = args.runtime;
+  const config = args.config;
+  return runByMode({
+    stream: args.stream,
+    mode,
+    run: (payload) => runTaskLifecycle(payload, runtime, config),
+    runLatest: (payload, context) => runTaskLifecycle(payload, runtime, config, context.isCurrent),
+    resolveConcurrencyLimit: resolveConcurrencyLimit(runtime),
+    latest: {
+      strategy: "fiber-slot",
+      // Keep TaskRunner behavior: triggers are acknowledged once started; no need to await final IO on stream completion.
+      awaitLatestOnEnd: false
+    }
+  });
+};
+var makeTaskRunner = (stream, mode, runtime, config) => runTask({
+  stream,
+  mode,
+  runtime,
+  config
+});
+
+// src/internal/runtime/core/TickScheduler.ts
+var batchDepth = 0;
+var batchWaiters = /* @__PURE__ */ new Set();
+var enterRuntimeBatch = () => {
+  batchDepth += 1;
+};
+var exitRuntimeBatch = () => {
+  batchDepth = Math.max(0, batchDepth - 1);
+  if (batchDepth !== 0) return;
+  const waiters = Array.from(batchWaiters);
+  batchWaiters.clear();
+  for (const w of waiters) {
+    try {
+      w.resolve();
+    } catch {
+    }
+  }
+};
+var waitForBatchEndIfNeeded = () => batchDepth === 0 ? Effect4.void : Effect4.promise(
+  (signal) => new Promise((resolve2) => {
+    let done = false;
+    const cleanup = () => {
+      if (done) return;
+      done = true;
+      batchWaiters.delete(waiter);
+      try {
+        signal.removeEventListener("abort", onAbort);
+      } catch {
+      }
+    };
+    const onAbort = () => {
+      cleanup();
+    };
+    const waiter = {
+      resolve: () => {
+        cleanup();
+        resolve2();
+      }
+    };
+    batchWaiters.add(waiter);
+    try {
+      signal.addEventListener("abort", onAbort, { once: true });
+    } catch {
+    }
+  })
+);
+var toSchedulingAnchor = (commit) => {
+  if (!commit) return void 0;
+  if (typeof commit.opSeq !== "number") return void 0;
+  return {
+    moduleId: commit.moduleId,
+    instanceId: commit.instanceId,
+    txnSeq: commit.meta.txnSeq,
+    txnId: commit.meta.txnId,
+    opSeq: commit.opSeq
+  };
+};
+var toSchedulingResolvedTxnSeq = (commit) => commit.schedulingPolicy?.resolvedAtTxnSeq ?? commit.meta.txnSeq;
+var toSchedulingResolvedOpSeq = (commit) => typeof commit.opSeq === "number" && Number.isFinite(commit.opSeq) ? commit.opSeq : -1;
+var pickNewerSchedulingCommit = (current, candidate) => {
+  if (!current) return candidate;
+  const currentTxnSeq = toSchedulingResolvedTxnSeq(current);
+  const candidateTxnSeq = toSchedulingResolvedTxnSeq(candidate);
+  if (candidateTxnSeq > currentTxnSeq) return candidate;
+  if (candidateTxnSeq < currentTxnSeq) return current;
+  return toSchedulingResolvedOpSeq(candidate) > toSchedulingResolvedOpSeq(current) ? candidate : current;
+};
+var clampSampleRate = (sampleRate) => {
+  if (typeof sampleRate !== "number" || !Number.isFinite(sampleRate)) return 0;
+  if (sampleRate <= 0) return 0;
+  if (sampleRate >= 1) return 1;
+  return sampleRate;
+};
+var shouldSampleTick = (tickSeq, sampleRate) => {
+  if (sampleRate <= 0) return false;
+  if (sampleRate >= 1) return true;
+  const x = tickSeq >>> 0;
+  const h = Math.imul(x ^ 2654435769, 2246822507) >>> 0;
+  return h / 4294967295 < sampleRate;
+};
+var topicKeyResolutionCacheLimit = 1024;
+var toTriggerKind = (originKind) => {
+  if (originKind === "action") return "dispatch";
+  if (originKind === "trait-external-store") return "externalStore";
+  if (originKind?.includes("timer")) return "timer";
+  return "unknown";
+};
+var toLane = (priority) => priority === "low" ? "nonUrgent" : "urgent";
+var maxPriority2 = (a, b) => a === "normal" || b === "normal" ? "normal" : "low";
+var mergeDrainInPlace = (base, next) => {
+  for (const [k, commit] of next.modules) {
+    const prev = base.modules.get(k);
+    if (!prev) {
+      base.modules.set(k, commit);
+    } else {
+      const mergedPriority = maxPriority2(prev.meta.priority, commit.meta.priority);
+      if (mergedPriority === commit.meta.priority) {
+        base.modules.set(k, commit);
+      } else {
+        base.modules.set(k, {
+          ...commit,
+          meta: {
+            ...commit.meta,
+            priority: mergedPriority
+          }
+        });
+      }
+    }
+  }
+  for (const [k, p] of next.dirtyTopics) {
+    const prev = base.dirtyTopics.get(k);
+    if (!prev) {
+      base.dirtyTopics.set(k, p);
+      continue;
+    }
+    const mergedPriority = maxPriority2(prev, p);
+    if (mergedPriority !== prev) {
+      base.dirtyTopics.set(k, mergedPriority);
+    }
+  }
+};
+var emptyDrain = () => ({ modules: /* @__PURE__ */ new Map(), dirtyTopics: /* @__PURE__ */ new Map() });
+var partitionModulesForBudget = (args) => {
+  let urgentCount = 0;
+  for (const commit of args.modules.values()) {
+    if (toLane(commit.meta.priority) === "urgent") {
+      urgentCount += 1;
+    }
+  }
+  const urgentCap = Math.max(0, args.urgentStepCap);
+  const urgentCapExceeded = urgentCount > urgentCap;
+  const nonUrgentBudget = Math.max(0, args.maxSteps);
+  let acceptedUrgentCount = 0;
+  let deferredNonUrgentCount = 0;
+  const acceptedModules = /* @__PURE__ */ new Map();
+  const deferredModules = /* @__PURE__ */ new Map();
+  for (const commit of args.modules.values()) {
+    if (toLane(commit.meta.priority) !== "urgent") continue;
+    if (urgentCapExceeded && acceptedUrgentCount >= urgentCap) {
+      deferredModules.set(commit.moduleInstanceKey, commit);
+      continue;
+    }
+    acceptedModules.set(commit.moduleInstanceKey, commit);
+    acceptedUrgentCount += 1;
+  }
+  if (urgentCapExceeded) {
+    for (const commit of args.modules.values()) {
+      if (toLane(commit.meta.priority) === "urgent") continue;
+      deferredModules.set(commit.moduleInstanceKey, commit);
+      deferredNonUrgentCount += 1;
+    }
+    return {
+      acceptedModules,
+      deferredModules,
+      urgentCapExceeded,
+      deferredNonUrgentCount
+    };
+  }
+  let acceptedNonUrgentCount = 0;
+  for (const commit of args.modules.values()) {
+    if (toLane(commit.meta.priority) === "urgent") continue;
+    if (acceptedNonUrgentCount >= nonUrgentBudget) {
+      deferredModules.set(commit.moduleInstanceKey, commit);
+      deferredNonUrgentCount += 1;
+      continue;
+    }
+    acceptedModules.set(commit.moduleInstanceKey, commit);
+    acceptedNonUrgentCount += 1;
+  }
+  return {
+    acceptedModules,
+    deferredModules,
+    urgentCapExceeded,
+    deferredNonUrgentCount
+  };
+};
+var makeTickScheduler = (args) => {
+  const store = args.runtimeStore;
+  const hostScheduler = args.hostScheduler;
+  const declarativeLinks = args.declarativeLinkRuntime;
+  const queue = args.queue ?? makeJobQueue();
+  const config = {
+    maxSteps: args.config?.maxSteps ?? 64,
+    urgentStepCap: args.config?.urgentStepCap ?? 512,
+    maxDrainRounds: args.config?.maxDrainRounds ?? 8,
+    microtaskChainDepthLimit: args.config?.microtaskChainDepthLimit ?? 32
+  };
+  const telemetry = args.config?.telemetry;
+  const telemetrySampleRate = clampSampleRate(telemetry?.sampleRate);
+  let tickSeq = 0;
+  let scheduled = false;
+  let microtaskChainDepth = 0;
+  let nextForcedReason;
+  let lastSchedulingDegrade;
+  let coalescedModules = 0;
+  let coalescedTopics = 0;
+  const topicKeyToModuleInstanceKeyCache = /* @__PURE__ */ new Map();
+  const rememberTopicKeyResolution = (topicKey, moduleInstanceKey) => {
+    if (topicKeyToModuleInstanceKeyCache.has(topicKey)) {
+      topicKeyToModuleInstanceKeyCache.delete(topicKey);
+    } else if (topicKeyToModuleInstanceKeyCache.size >= topicKeyResolutionCacheLimit) {
+      const oldestKey = topicKeyToModuleInstanceKeyCache.keys().next().value;
+      if (oldestKey !== void 0) {
+        topicKeyToModuleInstanceKeyCache.delete(oldestKey);
+      }
+    }
+    topicKeyToModuleInstanceKeyCache.set(topicKey, moduleInstanceKey ?? null);
+    return moduleInstanceKey;
+  };
+  const yieldMicrotask = Effect4.promise(
+    () => new Promise((resolve2) => {
+      hostScheduler.scheduleMicrotask(resolve2);
+    })
+  );
+  const yieldMacrotask = Effect4.promise(
+    (signal) => new Promise((resolve2) => {
+      const cancel = hostScheduler.scheduleMacrotask(resolve2);
+      try {
+        signal.addEventListener(
+          "abort",
+          () => {
+            cancel();
+          },
+          { once: true }
+        );
+      } catch {
+      }
+    })
+  );
+  const scheduleTick = () => Effect4.gen(function* () {
+    if (scheduled) return;
+    scheduled = true;
+    const waitedForBatch = batchDepth > 0;
+    const forcedReason = nextForcedReason;
+    nextForcedReason = void 0;
+    const shouldYieldForStarvation = forcedReason == null && microtaskChainDepth >= Math.max(1, config.microtaskChainDepthLimit);
+    const reason = forcedReason ?? (shouldYieldForStarvation ? "microtask_starvation" : void 0);
+    const boundary = reason ? "macrotask" : "microtask";
+    const startedAs = waitedForBatch ? "batch" : boundary;
+    const depthAtSchedule = microtaskChainDepth;
+    yield* Effect4.provideService(Effect4.gen(function* () {
+      try {
+        yield* waitForBatchEndIfNeeded();
+        if (boundary === "microtask") {
+          if (waitedForBatch) {
+            microtaskChainDepth = 0;
+          }
+          yield* yieldMicrotask;
+          if (!waitedForBatch) {
+            microtaskChainDepth += 1;
+          }
+        } else {
+          yield* yieldMacrotask;
+          microtaskChainDepth = 0;
+        }
+        const schedule = {
+          startedAs,
+          microtaskChainDepth: boundary === "macrotask" ? depthAtSchedule : microtaskChainDepth,
+          ...boundary === "macrotask" ? { forcedMacrotask: true, reason: reason ?? "unknown" } : {}
+        };
+        const outcome = yield* flushTick(schedule);
+        if (!outcome.stable) {
+          nextForcedReason = outcome.degradeReason === "budget_steps" ? "budget" : outcome.degradeReason === "cycle_detected" ? "cycle_detected" : "unknown";
+        }
+      } finally {
+        scheduled = false;
+        if (queue.hasPending()) {
+          yield* scheduleTick();
+        } else {
+          microtaskChainDepth = 0;
+        }
+      }
+    }), inSyncTransactionFiber, false).pipe(Effect4.forkDetach({ startImmediately: true }));
+  });
+  const flushTick = (schedule) => Effect4.gen(function* () {
+    if (!queue.hasPending()) {
+      return { stable: true };
+    }
+    tickSeq += 1;
+    const currentTickSeq = tickSeq;
+    const diagnosticsLevel = yield* Effect4.service(currentDiagnosticsLevel).pipe(Effect4.orDie);
+    const traceMode = yield* Effect4.service(currentTraceMode).pipe(Effect4.orDie);
+    const shouldEmitTrace = traceMode === "on" && diagnosticsLevel !== "off";
+    const shouldEmitSchedulingDiagnostics = diagnosticsLevel !== "off";
+    const captured = {
+      drainRounds: 0,
+      stable: true,
+      accepted: emptyDrain()
+    };
+    while (captured.drainRounds < config.maxDrainRounds) {
+      const drained = queue.drain();
+      if (!drained) break;
+      captured.drainRounds += 1;
+      mergeDrainInPlace(captured.accepted, drained);
+      if (declarativeLinks && drained.modules.size > 0) {
+        const changedModuleInstanceKeys = Array.from(drained.modules.keys());
+        yield* declarativeLinks.applyForSources({
+          tickSeq: currentTickSeq,
+          acceptedModules: captured.accepted.modules,
+          changedModuleInstanceKeys
+        });
+      }
+    }
+    if (queue.hasPending()) {
+      captured.stable = false;
+      captured.degradeReason = "cycle_detected";
+    }
+    let acceptedModules = captured.accepted.modules;
+    let deferredModules = void 0;
+    let urgentCapExceeded = false;
+    let deferredNonUrgentCount = 0;
+    if (!(captured.accepted.modules.size <= config.maxSteps && captured.accepted.modules.size <= config.urgentStepCap)) {
+      const partitioned = partitionModulesForBudget({
+        modules: captured.accepted.modules,
+        maxSteps: config.maxSteps,
+        urgentStepCap: config.urgentStepCap
+      });
+      acceptedModules = partitioned.acceptedModules;
+      deferredModules = partitioned.deferredModules;
+      urgentCapExceeded = partitioned.urgentCapExceeded;
+      deferredNonUrgentCount = partitioned.deferredNonUrgentCount;
+    }
+    if (urgentCapExceeded) {
+      captured.stable = false;
+      captured.degradeReason = "cycle_detected";
+    } else if (deferredNonUrgentCount > 0) {
+      captured.stable = false;
+      captured.degradeReason = captured.degradeReason ?? "budget_steps";
+    }
+    const canAcceptAllTopics = deferredModules == null || deferredModules.size === 0;
+    const acceptedDrain = (() => {
+      if (canAcceptAllTopics) {
+        if (captured.accepted.dirtyTopics.size === 0) {
+          return captured.accepted;
+        }
+        let hasNonParsable = false;
+        for (const topicKey of captured.accepted.dirtyTopics.keys()) {
+          if (!storeTopicToModuleInstanceKey(topicKey)) {
+            hasNonParsable = true;
+            break;
+          }
+        }
+        if (!hasNonParsable) {
+          return captured.accepted;
+        }
+        const acceptedTopics2 = /* @__PURE__ */ new Map();
+        for (const [topicKey, priority] of captured.accepted.dirtyTopics) {
+          const moduleInstanceKey = storeTopicToModuleInstanceKey(topicKey);
+          if (!moduleInstanceKey) continue;
+          acceptedTopics2.set(topicKey, priority);
+        }
+        return {
+          modules: acceptedModules,
+          dirtyTopics: acceptedTopics2
+        };
+      }
+      const acceptedTopics = /* @__PURE__ */ new Map();
+      const deferredTopics = /* @__PURE__ */ new Map();
+      for (const [topicKey, priority] of captured.accepted.dirtyTopics) {
+        const moduleInstanceKey = storeTopicToModuleInstanceKey(topicKey);
+        if (!moduleInstanceKey) continue;
+        if (acceptedModules.has(moduleInstanceKey)) {
+          acceptedTopics.set(topicKey, priority);
+        } else if (deferredModules && deferredModules.has(moduleInstanceKey)) {
+          deferredTopics.set(topicKey, priority);
+        } else {
+          acceptedTopics.set(topicKey, priority);
+        }
+      }
+      return {
+        modules: acceptedModules,
+        dirtyTopics: acceptedTopics
+      };
+    })();
+    const deferredDrain = canAcceptAllTopics || !deferredModules ? void 0 : deferredModules.size > 0 ? {
+      modules: deferredModules,
+      dirtyTopics: (() => {
+        const deferredTopics = /* @__PURE__ */ new Map();
+        for (const [topicKey, priority] of captured.accepted.dirtyTopics) {
+          const moduleInstanceKey = storeTopicToModuleInstanceKey(topicKey);
+          if (!moduleInstanceKey) continue;
+          if (deferredModules.has(moduleInstanceKey)) {
+            deferredTopics.set(topicKey, priority);
+          }
+        }
+        return deferredTopics;
+      })()
+    } : void 0;
+    captured.deferred = deferredDrain;
+    const anchorCommitForScheduling = (() => {
+      let selected;
+      for (const commit of acceptedModules.values()) {
+        selected = pickNewerSchedulingCommit(selected, commit);
+      }
+      if (deferredDrain) {
+        for (const commit of deferredDrain.modules.values()) {
+          selected = pickNewerSchedulingCommit(selected, commit);
+        }
+      }
+      return selected;
+    })();
+    const schedulingAnchor = toSchedulingAnchor(anchorCommitForScheduling);
+    const schedulingPolicy = anchorCommitForScheduling?.schedulingPolicy;
+    const schedulingConfigScope = schedulingPolicy?.configScope ?? "builtin";
+    const schedulingLimit = schedulingPolicy?.concurrencyLimit ?? 16;
+    const schedulingThreshold = schedulingPolicy?.pressureWarningThreshold ?? {
+      backlogCount: 1e3,
+      backlogDurationMs: 5e3
+    };
+    const schedulingCooldownMs = schedulingPolicy?.warningCooldownMs ?? 3e4;
+    const backlogCount = deferredDrain ? deferredDrain.modules.size + deferredDrain.dirtyTopics.size : 0;
+    if (!captured.stable && shouldEmitSchedulingDiagnostics && schedulingAnchor && !lastSchedulingDegrade) {
+      const reason = captured.degradeReason ?? "unknown";
+      yield* record({
+        type: "diagnostic",
+        moduleId: schedulingAnchor.moduleId,
+        instanceId: schedulingAnchor.instanceId,
+        txnSeq: schedulingAnchor.txnSeq,
+        txnId: schedulingAnchor.txnId,
+        opSeq: schedulingAnchor.opSeq,
+        code: "scheduling::degrade",
+        severity: "warning",
+        message: "Scheduling degraded: tick execution deferred part of the backlog.",
+        hint: "Inspect reason/backlog and align queue/tick/concurrency knobs through the same scheduling policy surface.",
+        kind: "scheduling:degrade",
+        trigger: {
+          kind: "tickScheduler",
+          name: "flushTick",
+          details: {
+            eventKind: "degrade",
+            reason,
+            tickSeq: currentTickSeq,
+            backlogCount,
+            configScope: schedulingConfigScope,
+            limit: schedulingLimit,
+            threshold: schedulingThreshold,
+            cooldownMs: schedulingCooldownMs,
+            schedule: {
+              startedAs: schedule.startedAs ?? "unknown",
+              forcedMacrotask: schedule.forcedMacrotask === true,
+              reason: schedule.reason ?? "unknown",
+              microtaskChainDepth: schedule.microtaskChainDepth ?? 0
+            }
+          }
+        }
+      });
+      lastSchedulingDegrade = {
+        tickSeq: currentTickSeq,
+        reason,
+        moduleId: schedulingAnchor.moduleId,
+        instanceId: schedulingAnchor.instanceId,
+        txnSeq: schedulingAnchor.txnSeq,
+        txnId: schedulingAnchor.txnId,
+        opSeq: schedulingAnchor.opSeq,
+        configScope: schedulingConfigScope,
+        limit: schedulingLimit,
+        backlogCount
+      };
+    } else if (captured.stable && lastSchedulingDegrade) {
+      const previous = lastSchedulingDegrade;
+      if (shouldEmitSchedulingDiagnostics) {
+        const recoverAnchor = schedulingAnchor ?? previous;
+        yield* record({
+          type: "diagnostic",
+          moduleId: recoverAnchor.moduleId,
+          instanceId: recoverAnchor.instanceId,
+          txnSeq: recoverAnchor.txnSeq,
+          txnId: recoverAnchor.txnId,
+          opSeq: recoverAnchor.opSeq,
+          code: "scheduling::recover",
+          severity: "info",
+          message: "Scheduling recovered: backlog/degrade condition cleared.",
+          hint: "No immediate action needed unless degrade/recover oscillates frequently.",
+          kind: "scheduling:recover",
+          trigger: {
+            kind: "tickScheduler",
+            name: "flushTick",
+            details: {
+              eventKind: "recover",
+              tickSeq: currentTickSeq,
+              fromTickSeq: previous.tickSeq,
+              fromReason: previous.reason,
+              previousBacklogCount: previous.backlogCount,
+              configScope: previous.configScope,
+              limit: previous.limit,
+              schedule: {
+                startedAs: schedule.startedAs ?? "unknown",
+                forcedMacrotask: schedule.forcedMacrotask === true,
+                reason: schedule.reason ?? "unknown",
+                microtaskChainDepth: schedule.microtaskChainDepth ?? 0
+              }
+            }
+          }
+        });
+      }
+      lastSchedulingDegrade = void 0;
+    }
+    let startedAtMs;
+    let triggerSummary;
+    let anchor;
+    let backlog;
+    let result;
+    if (shouldEmitTrace) {
+      startedAtMs = Date.now();
+      let triggerTotal = 0;
+      let triggerPrimary = void 0;
+      let triggerAnchor;
+      const triggerKindsOrder = [];
+      let externalStoreCount = 0;
+      let dispatchCount = 0;
+      let timerCount = 0;
+      let unknownCount = 0;
+      for (const commit of captured.accepted.modules.values()) {
+        if (!triggerAnchor) {
+          triggerAnchor = commit;
+        }
+        triggerTotal += 1;
+        const kind = toTriggerKind(commit.meta.originKind);
+        if (!triggerPrimary) {
+          triggerPrimary = {
+            kind,
+            moduleId: commit.moduleId,
+            instanceId: commit.instanceId,
+            fieldPath: kind === "externalStore" ? commit.meta.originName : void 0,
+            actionTag: kind === "dispatch" ? commit.meta.originName : void 0
+          };
+        }
+        switch (kind) {
+          case "externalStore": {
+            if (externalStoreCount === 0) triggerKindsOrder.push(kind);
+            externalStoreCount += 1;
+            break;
+          }
+          case "dispatch": {
+            if (dispatchCount === 0) triggerKindsOrder.push(kind);
+            dispatchCount += 1;
+            break;
+          }
+          case "timer": {
+            if (timerCount === 0) triggerKindsOrder.push(kind);
+            timerCount += 1;
+            break;
+          }
+          default: {
+            if (unknownCount === 0) triggerKindsOrder.push(kind);
+            unknownCount += 1;
+            break;
+          }
+        }
+      }
+      const kinds = [];
+      for (const kind of triggerKindsOrder) {
+        switch (kind) {
+          case "externalStore":
+            kinds.push({ kind, count: externalStoreCount });
+            break;
+          case "dispatch":
+            kinds.push({ kind, count: dispatchCount });
+            break;
+          case "timer":
+            kinds.push({ kind, count: timerCount });
+            break;
+          default:
+            kinds.push({ kind, count: unknownCount });
+            break;
+        }
+      }
+      triggerSummary = {
+        total: triggerTotal,
+        kinds,
+        primary: triggerPrimary,
+        coalescedCount: {
+          modules: coalescedModules,
+          topics: coalescedTopics
+        }
+      };
+      if (triggerAnchor) {
+        anchor = {
+          moduleId: triggerAnchor.moduleId,
+          instanceId: triggerAnchor.instanceId,
+          txnSeq: triggerAnchor.meta.txnSeq,
+          txnId: triggerAnchor.meta.txnId,
+          ...typeof triggerAnchor.opSeq === "number" ? { opSeq: triggerAnchor.opSeq } : null
+        };
+      }
+      const deferredWork = captured.deferred;
+      if (deferredWork) {
+        const pendingDeferredWork = deferredWork.modules.size + deferredWork.dirtyTopics.size;
+        let pendingExternalInputs = 0;
+        let firstDeferred;
+        let firstExternalStoreDeferred;
+        for (const deferred of deferredWork.modules.values()) {
+          if (!firstDeferred) {
+            firstDeferred = deferred;
+          }
+          const kind = toTriggerKind(deferred.meta.originKind);
+          if (kind === "externalStore") {
+            pendingExternalInputs += 1;
+            if (!firstExternalStoreDeferred) {
+              firstExternalStoreDeferred = deferred;
+            }
+          }
+        }
+        const primaryDeferred = firstExternalStoreDeferred ?? firstDeferred;
+        let deferredPrimary = void 0;
+        if (primaryDeferred) {
+          const kind = toTriggerKind(primaryDeferred.meta.originKind);
+          const isExternalStore = kind === "externalStore";
+          deferredPrimary = {
+            kind: isExternalStore ? "externalStore" : "unknown",
+            moduleId: primaryDeferred.moduleId,
+            instanceId: primaryDeferred.instanceId,
+            fieldPath: isExternalStore ? primaryDeferred.meta.originName : void 0,
+            storeId: void 0
+          };
+        }
+        backlog = {
+          pendingExternalInputs,
+          pendingDeferredWork,
+          deferredPrimary
+        };
+      }
+      result = {
+        stable: captured.stable,
+        ...captured.stable ? null : { degradeReason: captured.degradeReason ?? "unknown" }
+      };
+    }
+    if (shouldEmitTrace && schedule.forcedMacrotask && schedule.reason === "microtask_starvation") {
+      yield* record({
+        type: "warn:microtask-starvation",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        tickSeq: currentTickSeq,
+        microtaskChainDepth: schedule.microtaskChainDepth
+      });
+    }
+    if (shouldEmitTrace) {
+      yield* record({
+        type: "trace:tick",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        data: {
+          tickSeq: currentTickSeq,
+          phase: "start",
+          timestampMs: startedAtMs,
+          schedule,
+          triggerSummary,
+          anchors: anchor,
+          budget: {
+            maxSteps: config.maxSteps,
+            elapsedMs: 0,
+            steps: 0,
+            txnCount: acceptedModules.size
+          }
+        }
+      });
+    }
+    if (!captured.stable && shouldEmitTrace) {
+      yield* record({
+        type: "trace:tick",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        data: {
+          tickSeq: currentTickSeq,
+          phase: "budgetExceeded",
+          timestampMs: Date.now(),
+          schedule,
+          triggerSummary,
+          anchors: anchor,
+          budget: {
+            maxSteps: config.maxSteps,
+            elapsedMs: Math.max(0, Date.now() - startedAtMs),
+            steps: config.maxSteps,
+            txnCount: acceptedModules.size
+          },
+          backlog,
+          result
+        }
+      });
+    }
+    if (deferredDrain) {
+      queue.requeue(deferredDrain);
+    }
+    store.commitTick({
+      tickSeq: currentTickSeq,
+      accepted: acceptedDrain,
+      onListener: (listener) => listener()
+    });
+    if (!captured.stable && shouldEmitTrace && backlog?.deferredPrimary) {
+      const primary = backlog.deferredPrimary;
+      if (primary.kind === "externalStore") {
+        const moduleInstanceKey = primary.moduleId && primary.instanceId ? `${primary.moduleId}::${primary.instanceId}` : void 0;
+        if (moduleInstanceKey && store.getModuleSubscriberCount(moduleInstanceKey) > 0) {
+          yield* record({
+            type: "warn:priority-inversion",
+            moduleId: primary.moduleId,
+            instanceId: primary.instanceId,
+            tickSeq: currentTickSeq,
+            reason: "deferredBacklog"
+          });
+        }
+      }
+    }
+    if (shouldEmitTrace) {
+      yield* record({
+        type: "trace:tick",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        data: {
+          tickSeq: currentTickSeq,
+          phase: "settled",
+          timestampMs: Date.now(),
+          schedule,
+          triggerSummary,
+          anchors: anchor,
+          budget: {
+            maxSteps: config.maxSteps,
+            elapsedMs: Math.max(0, Date.now() - startedAtMs),
+            steps: acceptedModules.size,
+            txnCount: acceptedModules.size
+          },
+          backlog,
+          result
+        }
+      });
+    }
+    if (telemetry?.onTickDegraded && (schedule.forcedMacrotask || !captured.stable) && shouldSampleTick(currentTickSeq, telemetrySampleRate)) {
+      try {
+        telemetry.onTickDegraded({
+          tickSeq: currentTickSeq,
+          stable: captured.stable,
+          degradeReason: captured.stable ? void 0 : captured.degradeReason ?? "unknown",
+          forcedMacrotask: schedule.forcedMacrotask,
+          scheduleReason: schedule.reason,
+          microtaskChainDepth: schedule.microtaskChainDepth,
+          deferredWorkCount: deferredDrain ? deferredDrain.modules.size + deferredDrain.dirtyTopics.size : 0
+        });
+      } catch {
+      }
+    }
+    coalescedModules = 0;
+    coalescedTopics = 0;
+    return { stable: captured.stable, degradeReason: captured.degradeReason };
+  });
+  const flushNow = Effect4.gen(function* () {
+    const beforeTickSeq = tickSeq;
+    yield* flushTick({ startedAs: "unknown" });
+    if (tickSeq > beforeTickSeq) {
+      return;
+    }
+    if (!queue.hasPending() && !scheduled) {
+      return;
+    }
+    yield* Effect4.yieldNow;
+    if (tickSeq > beforeTickSeq) {
+      return;
+    }
+    if (queue.hasPending()) {
+      yield* flushTick({ startedAs: "unknown" });
+    }
+  }).pipe(Effect4.asVoid);
+  const storeTopicToModuleInstanceKey = (topicKey) => {
+    const cached = topicKeyToModuleInstanceKeyCache.get(topicKey);
+    if (cached !== void 0) {
+      return cached === null ? void 0 : cached;
+    }
+    const idx = topicKey.indexOf("::rq:");
+    if (idx > 0) {
+      return rememberTopicKeyResolution(topicKey, topicKey.slice(0, idx));
+    }
+    if (topicKey.includes("::")) {
+      return rememberTopicKeyResolution(topicKey, topicKey);
+    }
+    return rememberTopicKeyResolution(topicKey, void 0);
+  };
+  const onSelectorChanged = ({ moduleInstanceKey, selectorId, priority }) => {
+    const coalesced = queue.markTopicDirty(makeReadQueryTopicKey(moduleInstanceKey, selectorId), priority);
+    if (coalesced) coalescedTopics += 1;
+  };
+  const onModuleCommit = (commit) => Effect4.gen(function* () {
+    const coalescedCommit = queue.enqueueModuleCommit(commit);
+    if (coalescedCommit) coalescedModules += 1;
+    const coalescedTopic = queue.markTopicDirty(commit.moduleInstanceKey, commit.meta.priority);
+    if (coalescedTopic) coalescedTopics += 1;
+    yield* scheduleTick();
+  });
+  return {
+    getTickSeq: () => tickSeq,
+    onModuleCommit,
+    onSelectorChanged,
+    flushNow
+  };
+};
+
+export {
+  makeModuleInstanceKey,
+  enterRuntimeBatch,
+  exitRuntimeBatch,
+  getNodeEnv,
+  isDevEnv,
+  getDefaultStateTxnInstrumentation,
+  StateTransactionConfigTag,
+  ReadQueryStrictGateConfigTag,
+  ReplayModeConfigTag,
+  StateTransactionOverridesTag,
+  SchedulingPolicySurfaceTag,
+  SchedulingPolicySurfaceOverridesTag,
+  ConcurrencyPolicyTag,
+  RuntimeStoreTag,
+  runtimeStoreLayer,
+  HostSchedulerTag,
+  hostSchedulerLayer,
+  hostSchedulerTestStubLayer,
+  DeclarativeLinkRuntimeTag,
+  declarativeLinkRuntimeLayer,
+  TickSchedulerTag,
+  tickSchedulerLayer,
+  inSyncTransactionFiber,
+  forceSourceRefresh,
+  enterSyncTransactionShadow,
+  exitSyncTransactionShadow,
+  isInSyncTransactionShadow,
+  shouldNoopInSyncTransactionFiber,
+  makeTaskRunner
+};
+//# sourceMappingURL=chunk-S4S5N4BJ.js.map