@logixjs/core 0.0.1 → 0.0.2

package/dist/chunk-AQ7L2QZ5.js

@@ -0,0 +1,1395 @@
+import {
+  getGlobalHostScheduler
+} from "./chunk-MYKNINNN.js";
+import {
+  clearRuntimeDebugEventSeq,
+  currentDiagnosticsLevel,
+  record,
+  toRuntimeDebugEventRef
+} from "./chunk-ZC7MSQ5U.js";
+import {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage
+} from "./chunk-WYJUJV4L.js";
+
+// src/internal/runtime/core/DevtoolsHub.ts
+import { Effect, FiberRef } from "effect";
+var instances = /* @__PURE__ */ new Map();
+var latestStates = /* @__PURE__ */ new Map();
+var latestTraitSummaries = /* @__PURE__ */ new Map();
+var instanceLabels = /* @__PURE__ */ new Map();
+var convergeStaticIrByDigest = /* @__PURE__ */ new Map();
+var liveInstanceKeys = /* @__PURE__ */ new Set();
+var exportBudget = {
+  dropped: 0,
+  oversized: 0
+};
+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();
+var nextSeq = 1;
+var bufferSize = 500;
+var ringBuffer = [];
+var ringBufferSeq = [];
+var snapshotToken = 0;
+var ensureRingBufferSize = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (ringBuffer.length <= bufferSize) return;
+  const excess = ringBuffer.length - bufferSize;
+  ringBuffer.splice(0, excess);
+  ringBufferSeq.splice(0, excess);
+};
+var trimRingBufferIfNeeded = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (bufferSize <= 64) {
+    ensureRingBufferSize();
+    return;
+  }
+  const slack = Math.min(1024, Math.floor(bufferSize / 2));
+  const threshold = bufferSize + Math.max(1, slack);
+  if (ringBuffer.length <= threshold) return;
+  const excess = ringBuffer.length - bufferSize;
+  ringBuffer.splice(0, excess);
+  ringBufferSeq.splice(0, excess);
+};
+var currentSnapshot = {
+  snapshotToken,
+  instances,
+  events: ringBuffer,
+  latestStates,
+  latestTraitSummaries,
+  exportBudget
+};
+var listeners = /* @__PURE__ */ new Set();
+var notifyScheduled = false;
+var scheduleNotify = () => {
+  if (listeners.size === 0) return;
+  if (notifyScheduled) return;
+  notifyScheduled = true;
+  getGlobalHostScheduler().scheduleMicrotask(() => {
+    notifyScheduled = false;
+    for (const listener of listeners) {
+      listener();
+    }
+  });
+};
+var devtoolsEnabled = false;
+var bumpSnapshotToken = () => {
+  snapshotToken += 1;
+  currentSnapshot.snapshotToken = snapshotToken;
+};
+var markSnapshotChanged = () => {
+  bumpSnapshotToken();
+  scheduleNotify();
+};
+var configureDevtoolsHub = (options) => {
+  devtoolsEnabled = true;
+  if (typeof options?.bufferSize === "number" && Number.isFinite(options.bufferSize)) {
+    const next = Math.floor(options.bufferSize);
+    const nextBufferSize = next >= 0 ? next : 0;
+    if (nextBufferSize !== bufferSize) {
+      bufferSize = nextBufferSize;
+      ensureRingBufferSize();
+      markSnapshotChanged();
+    }
+  }
+};
+var isDevtoolsEnabled = () => devtoolsEnabled;
+var getDevtoolsSnapshot = () => currentSnapshot;
+var getDevtoolsSnapshotToken = () => snapshotToken;
+var subscribeDevtoolsSnapshot = (listener) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+var getDevtoolsRunId = () => currentRunId;
+var setDevtoolsRunId = (runId) => {
+  if (typeof runId !== "string" || runId.length === 0) return;
+  if (runId !== currentRunId) {
+    currentRunId = runId;
+    markSnapshotChanged();
+  }
+};
+var startDevtoolsRun = (runId) => {
+  currentRunId = typeof runId === "string" && runId.length > 0 ? runId : nextRunId();
+  nextSeq = 1;
+  clearRuntimeDebugEventSeq();
+  clearDevtoolsEvents();
+  return currentRunId;
+};
+var clearDevtoolsEvents = () => {
+  ringBuffer.length = 0;
+  ringBufferSeq.length = 0;
+  exportBudget.dropped = 0;
+  exportBudget.oversized = 0;
+  markSnapshotChanged();
+};
+var setInstanceLabel = (instanceId, label) => {
+  instanceLabels.set(instanceId, label);
+  markSnapshotChanged();
+};
+var getInstanceLabel = (instanceId) => instanceLabels.get(instanceId);
+var registerConvergeStaticIr = (ir) => {
+  convergeStaticIrByDigest.set(ir.staticIrDigest, ir);
+};
+var devtoolsHubConvergeStaticIrCollector = {
+  register: registerConvergeStaticIr
+};
+var exportDevtoolsEvidencePackage = (options) => {
+  const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
+  const runId = options?.runId ?? currentRunId;
+  const source = options?.source ?? { host: "unknown" };
+  const events = ringBuffer.map((payload, i) => ({
+    protocolVersion,
+    runId,
+    seq: ringBufferSeq[i] ?? i + 1,
+    timestamp: payload.timestamp,
+    type: "debug:event",
+    payload
+  }));
+  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const convergeDigests = /* @__PURE__ */ new Set();
+  let sawFullConverge = false;
+  for (const ref of ringBuffer) {
+    if (ref.kind !== "trait:converge") continue;
+    const meta = ref.meta;
+    if (!isRecord(meta)) continue;
+    const digest = meta.staticIrDigest;
+    if (typeof digest === "string" && digest.length > 0) {
+      convergeDigests.add(digest);
+    }
+    const dirty = meta.dirty;
+    if (isRecord(dirty) && typeof dirty.rootCount === "number") {
+      sawFullConverge = true;
+    }
+  }
+  let summary;
+  if (sawFullConverge && convergeDigests.size > 0) {
+    const staticIrByDigest = {};
+    for (const digest of convergeDigests) {
+      const ir = convergeStaticIrByDigest.get(digest);
+      if (ir) {
+        staticIrByDigest[digest] = ir;
+      }
+    }
+    if (Object.keys(staticIrByDigest).length > 0) {
+      summary = { converge: { staticIrByDigest } };
+    }
+  }
+  return exportEvidencePackage({
+    protocolVersion,
+    runId,
+    source,
+    events,
+    summary
+  });
+};
+var devtoolsHubSink = {
+  record: (event) => Effect.gen(function* () {
+    const level = yield* FiberRef.get(currentDiagnosticsLevel);
+    let changed = false;
+    if (event.type === "trace:instanceLabel") {
+      const instanceId = event.instanceId;
+      const data = event.data;
+      const label = data && typeof data === "object" && "label" in data ? String(data.label) : void 0;
+      if (instanceId && label) {
+        instanceLabels.set(instanceId, label);
+        changed = true;
+      }
+    }
+    if (event.type === "module:init" || event.type === "module:destroy") {
+      const moduleId = event.moduleId ?? "unknown";
+      const runtimeLabel = event.runtimeLabel ?? "unknown";
+      const instanceId = event.instanceId;
+      const key = `${runtimeLabel}::${moduleId}`;
+      const prev = instances.get(key) ?? 0;
+      if (event.type === "module:init") {
+        instances.set(key, prev + 1);
+        changed = true;
+        if (instanceId) {
+          const instanceKey = `${runtimeLabel}::${moduleId}::${instanceId}`;
+          liveInstanceKeys.add(instanceKey);
+          if (latestStates.delete(instanceKey)) changed = true;
+          if (latestTraitSummaries.delete(instanceKey)) changed = true;
+        }
+      } else {
+        const next = prev - 1;
+        if (next <= 0) {
+          if (instances.delete(key)) changed = true;
+        } else {
+          instances.set(key, next);
+          changed = true;
+        }
+        if (instanceId) {
+          const instanceKey = `${runtimeLabel}::${moduleId}::${instanceId}`;
+          liveInstanceKeys.delete(instanceKey);
+          if (latestStates.delete(instanceKey)) changed = true;
+          if (latestTraitSummaries.delete(instanceKey)) changed = true;
+          if (instanceLabels.delete(instanceId)) changed = true;
+          changed = true;
+        }
+      }
+    }
+    let exportBudgetChanged = false;
+    const ref = toRuntimeDebugEventRef(event, {
+      diagnosticsLevel: level,
+      resolveConvergeStaticIr: (staticIrDigest) => convergeStaticIrByDigest.get(staticIrDigest),
+      onMetaProjection: ({ stats }) => {
+        if (stats.dropped !== 0 || stats.oversized !== 0) {
+          exportBudgetChanged = true;
+        }
+        exportBudget.dropped += stats.dropped;
+        exportBudget.oversized += stats.oversized;
+      }
+    });
+    if (exportBudgetChanged) {
+      changed = true;
+    }
+    if (!ref) {
+      if (changed) {
+        markSnapshotChanged();
+      }
+      return;
+    }
+    if (ref.kind === "state" && ref.label === "state:update") {
+      const runtimeLabel = ref.runtimeLabel ?? "unknown";
+      const key = `${runtimeLabel}::${ref.moduleId}::${ref.instanceId}`;
+      if (liveInstanceKeys.has(key)) {
+        if (ref.meta && typeof ref.meta === "object" && !Array.isArray(ref.meta)) {
+          const anyMeta = ref.meta;
+          if ("state" in anyMeta) {
+            latestStates.set(key, anyMeta.state);
+            changed = true;
+          }
+          if ("traitSummary" in anyMeta && anyMeta.traitSummary !== void 0) {
+            latestTraitSummaries.set(key, anyMeta.traitSummary);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (bufferSize > 0) {
+      const seq = nextSeq++;
+      ringBuffer.push(ref);
+      ringBufferSeq.push(seq);
+      trimRingBufferIfNeeded();
+      changed = true;
+    }
+    if (changed) {
+      markSnapshotChanged();
+    }
+  })
+};
+
+// src/internal/runtime/core/TickScheduler.ts
+import { Effect as Effect5, FiberRef as FiberRef3 } 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 Effect4, Fiber, FiberRef as FiberRef2, Ref, Stream } from "effect";
+
+// src/internal/runtime/core/env.ts
+import { Context, Effect as Effect3, Layer } 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 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 listeners2 = Array.from(listenersByTopic.get(topicKey) ?? []);
+      if (listeners2.length > 0) {
+        changedTopics.set(topicKey, { priority, listeners: listeners2 });
+      }
+    }
+    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/DeclarativeLinkRuntime.ts
+import { Effect as Effect2 } 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) => Effect2.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 Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var StateTransactionConfigTag = StateTransactionConfigTagImpl;
+var ReadQueryStrictGateConfigTagImpl = class extends Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl;
+var ReplayModeConfigTagImpl = class extends Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var ReplayModeConfigTag = ReplayModeConfigTagImpl;
+var StateTransactionOverridesTagImpl = class extends Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var StateTransactionOverridesTag = StateTransactionOverridesTagImpl;
+var ConcurrencyPolicyTagImpl = class extends Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl;
+var ConcurrencyPolicyOverridesTagImpl = class extends Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+var ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl;
+var RuntimeStoreTag = class extends Context.Tag("@logixjs/core/RuntimeStore")() {
+};
+var runtimeStoreLayer = Layer.scoped(
+  RuntimeStoreTag,
+  Effect3.acquireRelease(
+    Effect3.sync(() => makeRuntimeStore()),
+    (store) => Effect3.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends Context.Tag("@logixjs/core/HostScheduler")() {
+};
+var hostSchedulerLayer = Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var hostSchedulerTestStubLayer = (scheduler) => Layer.succeed(HostSchedulerTag, scheduler);
+var DeclarativeLinkRuntimeTag = class extends Context.Tag("@logixjs/core/DeclarativeLinkRuntime")() {
+};
+var declarativeLinkRuntimeLayer = Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends Context.Tag("@logixjs/core/TickScheduler")() {
+};
+var tickSchedulerLayer = (config) => Layer.effect(
+  TickSchedulerTag,
+  Effect3.gen(function* () {
+    const store = yield* RuntimeStoreTag;
+    const declarativeLinkRuntime = yield* DeclarativeLinkRuntimeTag;
+    const hostScheduler = yield* HostSchedulerTag;
+    return makeTickScheduler({ runtimeStore: store, declarativeLinkRuntime, hostScheduler, config });
+  })
+);
+
+// src/internal/runtime/core/TaskRunner.ts
+var inSyncTransactionFiber = FiberRef2.unsafeMake(false);
+var forceSourceRefresh = FiberRef2.unsafeMake(false);
+var inSyncTransactionGlobalDepth = 0;
+var enterSyncTransaction = () => {
+  inSyncTransactionGlobalDepth += 1;
+};
+var exitSyncTransaction = () => {
+  inSyncTransactionGlobalDepth = Math.max(0, inSyncTransactionGlobalDepth - 1);
+};
+var isInSyncTransaction = () => inSyncTransactionGlobalDepth > 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) => Effect4.gen(function* () {
+  const inTxn = yield* FiberRef2.get(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(Effect4.map((p) => p.concurrencyLimit)) : Effect4.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => Effect4.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* Effect4.uninterruptible(
+      runtime.runWithStateTransaction(origins.pending, () => Effect4.asVoid(resolve(pending, payload)))
+    );
+  }
+  const io = resolve(config.effect, payload);
+  const exit = yield* Effect4.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, () => Effect4.asVoid(success(exit.value, payload)));
+    }
+    return;
+  }
+  const cause = exit.cause;
+  if (Cause.isInterrupted(cause)) {
+    return;
+  }
+  const failure = config.failure;
+  if (failure) {
+    yield* runtime.runWithStateTransaction(origins.failure, () => Effect4.asVoid(failure(cause, payload)));
+  }
+}).pipe(
+  // Watchers must not crash as a whole due to a single task failure: swallow errors, but keep them diagnosable.
+  Effect4.catchAllCause(
+    (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(Effect4.zipRight(Effect4.logError("TaskRunner error", cause)))
+  )
+);
+var makeTaskRunner = (stream, mode, runtime, config) => {
+  if (mode === "latest") {
+    return Effect4.gen(function* () {
+      const taskIdRef = yield* Ref.make(0);
+      const currentFiberRef = yield* Ref.make(void 0);
+      const start = (payload) => Effect4.gen(function* () {
+        const taskId = yield* Ref.updateAndGet(taskIdRef, (n) => n + 1);
+        const prev = yield* Ref.get(currentFiberRef);
+        if (prev) {
+          yield* Fiber.interruptFork(prev);
+        }
+        const canWriteBack = Ref.get(taskIdRef).pipe(Effect4.map((current) => current === taskId));
+        const fiber = yield* Effect4.fork(
+          runTaskLifecycle(payload, runtime, config, canWriteBack)
+        );
+        yield* Ref.set(currentFiberRef, fiber);
+      });
+      return yield* Stream.runForEach(stream, start);
+    });
+  }
+  if (mode === "exhaust") {
+    return Effect4.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      const busyRef = yield* Ref.make(false);
+      const mapper = (payload) => Effect4.gen(function* () {
+        const acquired = yield* Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runTaskLifecycle(payload, runtime, config);
+        } finally {
+          yield* Ref.set(busyRef, false);
+        }
+      });
+      return yield* Stream.runDrain(stream.pipe(Stream.mapEffect(mapper, { concurrency })));
+    });
+  }
+  if (mode === "parallel") {
+    return Effect4.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      return yield* Stream.runDrain(
+        stream.pipe(
+          Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
+            concurrency
+          })
+        )
+      );
+    });
+  }
+  return Stream.runForEach(
+    stream,
+    (payload) => runTaskLifecycle(payload, 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 ? Effect5.void : Effect5.async((resume, signal) => {
+  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();
+      resume(Effect5.void);
+    }
+  };
+  batchWaiters.add(waiter);
+  try {
+    signal.addEventListener("abort", onAbort, { once: true });
+  } catch {
+  }
+});
+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 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 mergeDrain = (base, next) => {
+  const modules = new Map(base.modules);
+  for (const [k, commit] of next.modules) {
+    const prev = modules.get(k);
+    if (!prev) {
+      modules.set(k, commit);
+    } else {
+      modules.set(k, {
+        ...commit,
+        meta: {
+          ...commit.meta,
+          priority: maxPriority2(prev.meta.priority, commit.meta.priority)
+        }
+      });
+    }
+  }
+  const dirtyTopics = new Map(base.dirtyTopics);
+  for (const [k, p] of next.dirtyTopics) {
+    const prev = dirtyTopics.get(k);
+    dirtyTopics.set(k, prev ? maxPriority2(prev, p) : p);
+  }
+  return { modules, dirtyTopics };
+};
+var emptyDrain = () => ({ modules: /* @__PURE__ */ new Map(), dirtyTopics: /* @__PURE__ */ new Map() });
+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 coalescedModules = 0;
+  let coalescedTopics = 0;
+  const yieldMicrotask = Effect5.async((resume) => {
+    hostScheduler.scheduleMicrotask(() => resume(Effect5.void));
+  });
+  const yieldMacrotask = Effect5.async((resume, signal) => {
+    const cancel = hostScheduler.scheduleMacrotask(() => resume(Effect5.void));
+    try {
+      signal.addEventListener(
+        "abort",
+        () => {
+          cancel();
+        },
+        { once: true }
+      );
+    } catch {
+    }
+  });
+  const scheduleTick = () => Effect5.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* Effect5.forkDaemon(
+      Effect5.locally(inSyncTransactionFiber, false)(
+        Effect5.gen(function* () {
+          try {
+            yield* waitForBatchEndIfNeeded();
+            if (boundary === "microtask") {
+              yield* yieldMicrotask;
+              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;
+            }
+          }
+        })
+      )
+    );
+  });
+  const flushTick = (schedule) => Effect5.gen(function* () {
+    if (!queue.hasPending()) {
+      return { stable: true };
+    }
+    tickSeq += 1;
+    const currentTickSeq = tickSeq;
+    const diagnosticsLevel = yield* FiberRef3.get(currentDiagnosticsLevel);
+    const shouldEmitTrace = isDevtoolsEnabled() && 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;
+      captured.accepted = mergeDrain(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";
+    }
+    const urgentModules = [];
+    const nonUrgentModules = [];
+    for (const commit of captured.accepted.modules.values()) {
+      if (toLane(commit.meta.priority) === "urgent") {
+        urgentModules.push(commit);
+      } else {
+        nonUrgentModules.push(commit);
+      }
+    }
+    const urgentCapExceeded = urgentModules.length > config.urgentStepCap;
+    const urgentAccepted = urgentCapExceeded ? urgentModules.slice(0, config.urgentStepCap) : urgentModules;
+    const urgentDeferred = urgentCapExceeded ? urgentModules.slice(config.urgentStepCap) : [];
+    const nonUrgentBudget = Math.max(0, config.maxSteps);
+    const nonUrgentAccepted = urgentCapExceeded ? [] : nonUrgentModules.slice(0, nonUrgentBudget);
+    const nonUrgentDeferred = urgentCapExceeded ? nonUrgentModules : nonUrgentModules.slice(nonUrgentBudget);
+    if (urgentCapExceeded) {
+      captured.stable = false;
+      captured.degradeReason = "cycle_detected";
+    } else if (nonUrgentDeferred.length > 0) {
+      captured.stable = false;
+      captured.degradeReason = captured.degradeReason ?? "budget_steps";
+    }
+    const acceptedModules = /* @__PURE__ */ new Map();
+    const deferredModules = /* @__PURE__ */ new Map();
+    for (const c of urgentAccepted) acceptedModules.set(c.moduleInstanceKey, c);
+    for (const c of nonUrgentAccepted) acceptedModules.set(c.moduleInstanceKey, c);
+    for (const c of urgentDeferred) deferredModules.set(c.moduleInstanceKey, c);
+    for (const c of nonUrgentDeferred) deferredModules.set(c.moduleInstanceKey, c);
+    const acceptedTopics = /* @__PURE__ */ new Map();
+    const deferredTopics = /* @__PURE__ */ new Map();
+    for (const [topicKey, priority] of captured.accepted.dirtyTopics) {
+      const info = storeTopicToModuleInstanceKey(topicKey);
+      if (!info) continue;
+      if (acceptedModules.has(info)) {
+        acceptedTopics.set(topicKey, priority);
+      } else if (deferredModules.has(info)) {
+        deferredTopics.set(topicKey, priority);
+      } else {
+        acceptedTopics.set(topicKey, priority);
+      }
+    }
+    const acceptedDrain = {
+      modules: acceptedModules,
+      dirtyTopics: acceptedTopics
+    };
+    const deferredDrain = deferredModules.size > 0 || deferredTopics.size > 0 ? {
+      modules: deferredModules,
+      dirtyTopics: deferredTopics
+    } : void 0;
+    captured.deferred = deferredDrain;
+    let startedAtMs;
+    let triggerSummary;
+    let anchor;
+    let backlog;
+    let result;
+    if (shouldEmitTrace) {
+      startedAtMs = Date.now();
+      triggerSummary = (() => {
+        const triggers = Array.from(captured.accepted.modules.values());
+        const counts = /* @__PURE__ */ new Map();
+        let primary = void 0;
+        for (const t of triggers) {
+          const kind = toTriggerKind(t.meta.originKind);
+          counts.set(kind, (counts.get(kind) ?? 0) + 1);
+          if (!primary) {
+            primary = {
+              kind,
+              moduleId: t.moduleId,
+              instanceId: t.instanceId,
+              fieldPath: kind === "externalStore" ? t.meta.originName : void 0,
+              actionTag: kind === "dispatch" ? t.meta.originName : void 0
+            };
+          }
+        }
+        return {
+          total: triggers.length,
+          kinds: Array.from(counts.entries()).map(([kind, count]) => ({ kind, count })),
+          primary,
+          coalescedCount: {
+            modules: coalescedModules,
+            topics: coalescedTopics
+          }
+        };
+      })();
+      anchor = (() => {
+        const first = captured.accepted.modules.values().next().value;
+        if (!first) return void 0;
+        return {
+          moduleId: first.moduleId,
+          instanceId: first.instanceId,
+          txnSeq: first.meta.txnSeq,
+          txnId: first.meta.txnId,
+          ...typeof first.opSeq === "number" ? { opSeq: first.opSeq } : null
+        };
+      })();
+      backlog = (() => {
+        const deferredWork = captured.deferred;
+        if (!deferredWork) return void 0;
+        const pendingDeferredWork = deferredWork.modules.size + deferredWork.dirtyTopics.size;
+        const deferredModulesList = Array.from(deferredWork.modules.values());
+        const pendingExternalInputs = deferredModulesList.filter((m) => toTriggerKind(m.meta.originKind) === "externalStore").length;
+        const primaryDeferred = deferredModulesList.find((m) => toTriggerKind(m.meta.originKind) === "externalStore") ?? deferredModulesList[0];
+        const kind = primaryDeferred ? toTriggerKind(primaryDeferred.meta.originKind) : "unknown";
+        const deferredPrimary = primaryDeferred != null ? {
+          kind: kind === "externalStore" ? "externalStore" : "unknown",
+          moduleId: primaryDeferred.moduleId,
+          instanceId: primaryDeferred.instanceId,
+          fieldPath: kind === "externalStore" ? primaryDeferred.meta.originName : void 0,
+          storeId: void 0
+        } : void 0;
+        return {
+          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);
+    }
+    const committed = store.commitTick({
+      tickSeq: currentTickSeq,
+      accepted: acceptedDrain
+    });
+    for (const { listeners: listeners2 } of committed.changedTopics.values()) {
+      for (const listener of listeners2) {
+        try {
+          listener();
+        } catch {
+        }
+      }
+    }
+    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 = flushTick({ startedAs: "unknown" }).pipe(Effect5.asVoid);
+  const storeTopicToModuleInstanceKey = (topicKey) => {
+    const idx = topicKey.indexOf("::rq:");
+    if (idx > 0) {
+      return topicKey.slice(0, idx);
+    }
+    if (topicKey.includes("::")) {
+      return topicKey;
+    }
+    return void 0;
+  };
+  const onSelectorChanged = ({ moduleInstanceKey, selectorId, priority }) => {
+    const coalesced = queue.markTopicDirty(makeReadQueryTopicKey(moduleInstanceKey, selectorId), priority);
+    if (coalesced) coalescedTopics += 1;
+  };
+  const onModuleCommit = (commit) => Effect5.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,
+  configureDevtoolsHub,
+  isDevtoolsEnabled,
+  getDevtoolsSnapshot,
+  getDevtoolsSnapshotToken,
+  subscribeDevtoolsSnapshot,
+  getDevtoolsRunId,
+  setDevtoolsRunId,
+  startDevtoolsRun,
+  clearDevtoolsEvents,
+  setInstanceLabel,
+  getInstanceLabel,
+  devtoolsHubConvergeStaticIrCollector,
+  exportDevtoolsEvidencePackage,
+  devtoolsHubSink,
+  enterRuntimeBatch,
+  exitRuntimeBatch,
+  getNodeEnv,
+  isDevEnv,
+  getDefaultStateTxnInstrumentation,
+  StateTransactionConfigTag,
+  ReadQueryStrictGateConfigTag,
+  ReplayModeConfigTag,
+  StateTransactionOverridesTag,
+  ConcurrencyPolicyTag,
+  ConcurrencyPolicyOverridesTag,
+  RuntimeStoreTag,
+  runtimeStoreLayer,
+  HostSchedulerTag,
+  hostSchedulerLayer,
+  hostSchedulerTestStubLayer,
+  DeclarativeLinkRuntimeTag,
+  declarativeLinkRuntimeLayer,
+  TickSchedulerTag,
+  tickSchedulerLayer,
+  inSyncTransactionFiber,
+  forceSourceRefresh,
+  enterSyncTransaction,
+  exitSyncTransaction,
+  isInSyncTransaction,
+  shouldNoopInSyncTransactionFiber,
+  makeTaskRunner
+};
+//# sourceMappingURL=chunk-AQ7L2QZ5.js.map