@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,1395 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  getGlobalHostScheduler
+} from "./chunk-UJGVDFZN.js";
+import {
+  clearRuntimeDebugEventSeq,
+  currentDiagnosticsLevel,
+  record,
+  toRuntimeDebugEventRef
+} from "./chunk-SH7TP5CJ.js";
+import {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage
+} from "./chunk-SI5OKFFY.js";
+
+// ../logix-core/src/internal/runtime/core/DevtoolsHub.ts
+import { Effect, FiberRef } from "../effect.js";
+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();
+    }
+  })
+};
+
+// ../logix-core/src/internal/runtime/core/TickScheduler.ts
+import { Effect as Effect5, FiberRef as FiberRef3 } from "../effect.js";
+
+// ../logix-core/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
+  };
+};
+
+// ../logix-core/src/internal/runtime/core/TaskRunner.ts
+import { Cause, Effect as Effect4, Fiber, FiberRef as FiberRef2, Ref, Stream } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/env.ts
+import { Context, Effect as Effect3, Layer } from "../effect.js";
+
+// ../logix-core/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
+  };
+};
+
+// ../logix-core/src/internal/runtime/core/DeclarativeLinkRuntime.ts
+import { Effect as Effect2 } from "../effect.js";
+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
+  };
+};
+
+// ../logix-core/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 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 });
+  })
+);
+
+// ../logix-core/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)
+  );
+};
+
+// ../logix-core/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,
+  DeclarativeLinkRuntimeTag,
+  declarativeLinkRuntimeLayer,
+  TickSchedulerTag,
+  tickSchedulerLayer,
+  inSyncTransactionFiber,
+  forceSourceRefresh,
+  enterSyncTransaction,
+  exitSyncTransaction,
+  isInSyncTransaction,
+  shouldNoopInSyncTransactionFiber,
+  makeTaskRunner
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/DevtoolsHub.ts", "../../../../logix-core/src/internal/runtime/core/TickScheduler.ts", "../../../../logix-core/src/internal/runtime/core/JobQueue.ts", "../../../../logix-core/src/internal/runtime/core/TaskRunner.ts", "../../../../logix-core/src/internal/runtime/core/env.ts", "../../../../logix-core/src/internal/runtime/core/RuntimeStore.ts", "../../../../logix-core/src/internal/runtime/core/DeclarativeLinkRuntime.ts"],
  "sourcesContent": ["import { Effect, FiberRef } from 'effect'\nimport type { JsonValue } from '../../observability/jsonValue.js'\nimport type { EvidencePackage, EvidencePackageSource } from '../../observability/evidence.js'\nimport { exportEvidencePackage, OBSERVABILITY_PROTOCOL_VERSION } from '../../observability/evidence.js'\nimport type { ConvergeStaticIrExport } from '../../state-trait/converge-ir.js'\nimport type { ConvergeStaticIrCollector } from './ConvergeStaticIrCollector.js'\nimport {\n  currentDiagnosticsLevel,\n  clearRuntimeDebugEventSeq,\n  toRuntimeDebugEventRef,\n  type Event,\n  type RuntimeDebugEventRef,\n  type Sink,\n} from './DebugSink.js'\nimport { getGlobalHostScheduler } from './HostScheduler.js'\n\n/**\n * DevtoolsHub\uFF1A\n * - Process/page-level Debug event aggregator (global singleton).\n *\n * Note: this hub is only appended to Debug sinks when devtoolsHubLayer is explicitly enabled.\n * The Snapshot API is always available (returns empty snapshots when disabled).\n *\n * Performance:\n * - Devtools Debug events can be extremely dense in hot paths (EffectOp / Trait / StateTxn, etc.).\n * - The previous implementation copied ringBuffer and Maps per event to build an \"immutable snapshot\" (O(bufferSize)).\n * - The current implementation lets Snapshot reference internal Map/Array directly (read-only convention) and batches\n *   subscriber notifications in microtasks, avoiding per-event copies and reducing main-thread interference.\n */\n\nexport interface DevtoolsSnapshot {\n  /**\n   * SnapshotToken\uFF1A\n   * - Monotonic snapshot change token (a subscription-safe source of truth).\n   * - Any externally visible change must advance the token.\n   * - If the token does not change, externally visible snapshot fields must not change (avoid tearing / missed updates).\n   */\n  readonly snapshotToken: SnapshotToken\n  readonly instances: ReadonlyMap<string, number>\n  readonly events: ReadonlyArray<RuntimeDebugEventRef>\n  readonly latestStates: ReadonlyMap<string, JsonValue>\n  readonly latestTraitSummaries: ReadonlyMap<string, JsonValue>\n  /**\n   * exportBudget\uFF1A\n   * - Tracks \"degrade counts\" caused by export boundaries (JsonValue projection/trimming), for explainability.\n   * - Counts are cumulative (may differ from the ring buffer window); clearDevtoolsEvents resets them.\n   */\n  readonly exportBudget: {\n    readonly dropped: number\n    readonly oversized: number\n  }\n}\n\nexport interface DevtoolsHubOptions {\n  readonly bufferSize?: number\n}\n\nexport type SnapshotToken = number\n\n// ---- Global mutable state (singleton) ----\n\nconst instances = new Map<string, number>()\nconst latestStates = new Map<string, JsonValue>()\nconst latestTraitSummaries = new Map<string, JsonValue>()\nconst instanceLabels = new Map<string, string>()\nconst convergeStaticIrByDigest = new Map<string, ConvergeStaticIrExport>()\nconst liveInstanceKeys = new Set<string>()\n\nconst exportBudget = {\n  dropped: 0,\n  oversized: 0,\n}\n\nlet lastRunTs = 0\nlet lastRunTsSeq = 0\n\nconst nextRunId = (): string => {\n  const ts = Date.now()\n  if (ts === lastRunTs) {\n    lastRunTsSeq += 1\n  } else {\n    lastRunTs = ts\n    lastRunTsSeq = 0\n  }\n\n  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`\n}\n\nlet currentRunId = nextRunId()\nlet nextSeq = 1\n\nlet bufferSize = 500\nconst ringBuffer: RuntimeDebugEventRef[] = []\nconst ringBufferSeq: number[] = []\n\nlet snapshotToken: SnapshotToken = 0\n\nconst ensureRingBufferSize = (): void => {\n  if (bufferSize <= 0) {\n    ringBuffer.length = 0\n    ringBufferSeq.length = 0\n    return\n  }\n\n  if (ringBuffer.length <= bufferSize) return\n  const excess = ringBuffer.length - bufferSize\n  ringBuffer.splice(0, excess)\n  ringBufferSeq.splice(0, excess)\n}\n\nconst trimRingBufferIfNeeded = (): void => {\n  if (bufferSize <= 0) {\n    ringBuffer.length = 0\n    ringBufferSeq.length = 0\n    return\n  }\n\n  // Small windows keep a strict upper bound to avoid \"size=5 but events.length briefly > 5\" surprises.\n  // Large windows allow short bursts + batch trimming to avoid linear shift() costs under sustained load.\n  if (bufferSize <= 64) {\n    ensureRingBufferSize()\n    return\n  }\n\n  const slack = Math.min(1024, Math.floor(bufferSize / 2))\n  const threshold = bufferSize + Math.max(1, slack)\n  if (ringBuffer.length <= threshold) return\n\n  const excess = ringBuffer.length - bufferSize\n  ringBuffer.splice(0, excess)\n  ringBufferSeq.splice(0, excess)\n}\n\n// Snapshot references internal structures directly (read-only convention) to avoid copy costs in hot paths.\nconst currentSnapshot: DevtoolsSnapshot = {\n  snapshotToken,\n  instances,\n  events: ringBuffer,\n  latestStates,\n  latestTraitSummaries,\n  exportBudget,\n}\n\nconst listeners = new Set<() => void>()\n\nlet notifyScheduled = false\nconst scheduleNotify = () => {\n  if (listeners.size === 0) return\n  if (notifyScheduled) return\n  notifyScheduled = true\n  getGlobalHostScheduler().scheduleMicrotask(() => {\n    notifyScheduled = false\n    for (const listener of listeners) {\n      listener()\n    }\n  })\n}\n\nlet devtoolsEnabled = false\n\nconst bumpSnapshotToken = (): void => {\n  snapshotToken += 1\n  ;(currentSnapshot as any).snapshotToken = snapshotToken\n}\n\nconst markSnapshotChanged = (): void => {\n  bumpSnapshotToken()\n  scheduleNotify()\n}\n\nexport const configureDevtoolsHub = (options?: DevtoolsHubOptions) => {\n  devtoolsEnabled = true\n  if (typeof options?.bufferSize === 'number' && Number.isFinite(options.bufferSize)) {\n    const next = Math.floor(options.bufferSize)\n    const nextBufferSize = next >= 0 ? next : 0\n    if (nextBufferSize !== bufferSize) {\n      bufferSize = nextBufferSize\n      ensureRingBufferSize()\n      markSnapshotChanged()\n    }\n  }\n}\n\nexport const isDevtoolsEnabled = (): boolean => devtoolsEnabled\n\n// ---- Snapshot public helpers ----\n\nexport const getDevtoolsSnapshot = (): DevtoolsSnapshot => currentSnapshot\nexport const getDevtoolsSnapshotToken = (): SnapshotToken => snapshotToken\n\nexport const subscribeDevtoolsSnapshot = (listener: () => void): (() => void) => {\n  listeners.add(listener)\n  return () => {\n    listeners.delete(listener)\n  }\n}\n\nexport const getDevtoolsRunId = (): string => currentRunId\n\nexport const setDevtoolsRunId = (runId: string): void => {\n  if (typeof runId !== 'string' || runId.length === 0) return\n  if (runId !== currentRunId) {\n    currentRunId = runId\n    markSnapshotChanged()\n  }\n}\n\nexport const startDevtoolsRun = (runId?: string): string => {\n  currentRunId = typeof runId === 'string' && runId.length > 0 ? runId : nextRunId()\n  nextSeq = 1\n  clearRuntimeDebugEventSeq()\n  clearDevtoolsEvents()\n  return currentRunId\n}\n\nexport const clearDevtoolsEvents = (): void => {\n  ringBuffer.length = 0\n  ringBufferSeq.length = 0\n  exportBudget.dropped = 0\n  exportBudget.oversized = 0\n  markSnapshotChanged()\n}\n\nexport const setInstanceLabel = (instanceId: string, label: string): void => {\n  instanceLabels.set(instanceId, label)\n  markSnapshotChanged()\n}\n\nexport const getInstanceLabel = (instanceId: string): string | undefined => instanceLabels.get(instanceId)\n\nconst registerConvergeStaticIr = (ir: ConvergeStaticIrExport): void => {\n  convergeStaticIrByDigest.set(ir.staticIrDigest, ir)\n}\n\nexport const devtoolsHubConvergeStaticIrCollector: ConvergeStaticIrCollector = {\n  register: registerConvergeStaticIr,\n}\n\nexport const exportDevtoolsEvidencePackage = (options?: {\n  readonly runId?: string\n  readonly source?: EvidencePackageSource\n  readonly protocolVersion?: string\n}): EvidencePackage => {\n  const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION\n  const runId = options?.runId ?? currentRunId\n  const source = options?.source ?? { host: 'unknown' }\n\n  const events = ringBuffer.map((payload, i) => ({\n    protocolVersion,\n    runId,\n    seq: ringBufferSeq[i] ?? i + 1,\n    timestamp: payload.timestamp,\n    type: 'debug:event',\n    payload: payload as unknown as JsonValue,\n  }))\n\n  const isRecord = (value: unknown): value is Record<string, unknown> =>\n    typeof value === 'object' && value !== null && !Array.isArray(value)\n\n  // In full diagnostics: de-duplicate by staticIrDigest and export matching ConvergeStaticIR (for offline explanation/replay).\n  const convergeDigests = new Set<string>()\n  let sawFullConverge = false\n\n  for (const ref of ringBuffer) {\n    if (ref.kind !== 'trait:converge') continue\n    const meta = ref.meta\n    if (!isRecord(meta)) continue\n\n    const digest = meta.staticIrDigest\n    if (typeof digest === 'string' && digest.length > 0) {\n      convergeDigests.add(digest)\n    }\n\n    const dirty = meta.dirty\n    if (isRecord(dirty) && typeof dirty.rootCount === 'number') {\n      sawFullConverge = true\n    }\n  }\n\n  let summary: JsonValue | undefined\n  if (sawFullConverge && convergeDigests.size > 0) {\n    const staticIrByDigest: Record<string, JsonValue> = {}\n    for (const digest of convergeDigests) {\n      const ir = convergeStaticIrByDigest.get(digest)\n      if (ir) {\n        staticIrByDigest[digest] = ir as unknown as JsonValue\n      }\n    }\n    if (Object.keys(staticIrByDigest).length > 0) {\n      summary = { converge: { staticIrByDigest } } as unknown as JsonValue\n    }\n  }\n\n  return exportEvidencePackage({\n    protocolVersion,\n    runId,\n    source,\n    events,\n    summary,\n  })\n}\n\n// ---- Hub Sink ----\n\nexport const devtoolsHubSink: Sink = {\n  record: (event: Event) =>\n    Effect.gen(function* () {\n      // NOTE: the hub is a global singleton, but whether events are exportable/written to the buffer is controlled by FiberRef,\n      // enabling different perf baselines/diagnostics tiers across scopes within the same process.\n      const level = yield* FiberRef.get(currentDiagnosticsLevel)\n\n      let changed = false\n\n      // trace:instanceLabel: set a human-readable label for a runtime instance.\n      if (event.type === 'trace:instanceLabel') {\n        const instanceId = (event as any).instanceId as string | undefined\n        const data = (event as any).data\n        const label = data && typeof data === 'object' && 'label' in data ? String((data as any).label) : undefined\n        if (instanceId && label) {\n          instanceLabels.set(instanceId, label)\n          changed = true\n        }\n      }\n\n      // Instance counters: maintain active instance counts by runtimeLabel::moduleId.\n      if (event.type === 'module:init' || event.type === 'module:destroy') {\n        const moduleId = (event as any).moduleId ?? 'unknown'\n        const runtimeLabel = (event as any).runtimeLabel ?? 'unknown'\n        const instanceId = (event as any).instanceId as string | undefined\n        const key = `${runtimeLabel}::${moduleId}`\n        const prev = instances.get(key) ?? 0\n        if (event.type === 'module:init') {\n          instances.set(key, prev + 1)\n          changed = true\n          if (instanceId) {\n            const instanceKey = `${runtimeLabel}::${moduleId}::${instanceId}`\n            liveInstanceKeys.add(instanceKey)\n            // If instanceId is reused, ensure derived caches do not carry leftovers from the previous lifetime.\n            if (latestStates.delete(instanceKey)) changed = true\n            if (latestTraitSummaries.delete(instanceKey)) changed = true\n          }\n        } else {\n          const next = prev - 1\n          if (next <= 0) {\n            if (instances.delete(key)) changed = true\n          } else {\n            instances.set(key, next)\n            changed = true\n          }\n\n          if (instanceId) {\n            const instanceKey = `${runtimeLabel}::${moduleId}::${instanceId}`\n            liveInstanceKeys.delete(instanceKey)\n            if (latestStates.delete(instanceKey)) changed = true\n            if (latestTraitSummaries.delete(instanceKey)) changed = true\n            if (instanceLabels.delete(instanceId)) changed = true\n            changed = true\n          }\n        }\n      }\n\n      let exportBudgetChanged = false\n      const ref = toRuntimeDebugEventRef(event, {\n        diagnosticsLevel: level,\n        resolveConvergeStaticIr: (staticIrDigest) => convergeStaticIrByDigest.get(staticIrDigest),\n        onMetaProjection: ({ stats }) => {\n          if (stats.dropped !== 0 || stats.oversized !== 0) {\n            exportBudgetChanged = true\n          }\n          exportBudget.dropped += stats.dropped\n          exportBudget.oversized += stats.oversized\n        },\n      })\n      if (exportBudgetChanged) {\n        changed = true\n      }\n      if (!ref) {\n        // off tier: do not write ring buffer / latestStates, but keep minimal counters/labels (including module:destroy cleanup).\n        if (changed) {\n          markSnapshotChanged()\n        }\n        return\n      }\n\n      // latestStates / latestTraitSummaries: record latest snapshots by runtimeLabel::moduleId::instanceId.\n      if (ref.kind === 'state' && ref.label === 'state:update') {\n        const runtimeLabel = ref.runtimeLabel ?? 'unknown'\n        const key = `${runtimeLabel}::${ref.moduleId}::${ref.instanceId}`\n\n        // Late/replayed events after module:destroy: allow entering the window for replay, but do not rebuild latest* caches.\n        if (liveInstanceKeys.has(key)) {\n          if (ref.meta && typeof ref.meta === 'object' && !Array.isArray(ref.meta)) {\n            const anyMeta = ref.meta as any\n            if ('state' in anyMeta) {\n              latestStates.set(key, anyMeta.state as JsonValue)\n              changed = true\n            }\n            if ('traitSummary' in anyMeta && anyMeta.traitSummary !== undefined) {\n              latestTraitSummaries.set(key, anyMeta.traitSummary as JsonValue)\n              changed = true\n            }\n          }\n        }\n      }\n\n      // ring buffer: keep the most recent bufferSize RuntimeDebugEventRefs.\n      if (bufferSize > 0) {\n        const seq = nextSeq++\n        ringBuffer.push(ref)\n        ringBufferSeq.push(seq)\n        trimRingBufferIfNeeded()\n        changed = true\n      }\n\n      if (changed) {\n        markSnapshotChanged()\n      }\n    }),\n}\n", "import { Effect, FiberRef } from 'effect'\nimport * as Debug from './DebugSink.js'\nimport * as DevtoolsHub from './DevtoolsHub.js'\nimport type { DeclarativeLinkRuntime } from './DeclarativeLinkRuntime.js'\nimport type { HostScheduler } from './HostScheduler.js'\nimport { makeJobQueue, type JobQueue } from './JobQueue.js'\nimport * as TaskRunner from './TaskRunner.js'\nimport {\n  makeReadQueryTopicKey,\n  type ModuleInstanceKey,\n  type RuntimeStore,\n  type RuntimeStoreModuleCommit,\n  type RuntimeStorePendingDrain,\n} from './RuntimeStore.js'\nimport type { StateCommitPriority } from './module.js'\n\nexport type TickLane = 'urgent' | 'nonUrgent'\n\nexport type TickDegradeReason = 'budget_steps' | 'cycle_detected' | 'unknown'\n\nexport interface TickSchedulerConfig {\n  /**\n   * Fixpoint step cap:\n   * - Steps count \"work acceptance units\" within a single tick, not time.\n   * - Exceeding the budget triggers a soft degrade (stable=false), deferring nonUrgent backlog to the next tick.\n   */\n  readonly maxSteps?: number\n  /**\n   * Urgent safety cap:\n   * - Even urgent work may be cut when the system appears to be in a cycle (avoid freezing).\n   */\n  readonly urgentStepCap?: number\n  /**\n   * Drain-round cap:\n   * - Bounds the number of drain rounds while capturing concurrent commits before committing the tick snapshot.\n   * - Exceeding the cap is treated as a cycle (stable=false, degradeReason=cycle_detected).\n   */\n  readonly maxDrainRounds?: number\n  /**\n   * Microtask starvation protection threshold:\n   * - Counts consecutive ticks scheduled on microtask boundaries without yielding to host (best-effort).\n   * - Exceeding the limit forces the next tick to start on a macrotask boundary.\n   */\n  readonly microtaskChainDepthLimit?: number\n  /**\n   * Optional degraded-tick telemetry (opt-in, sampled):\n   * - Runs even when diagnostics=off (Devtools disabled).\n   * - Intended for production health signals (frequency of stable=false / forced yield).\n   */\n  readonly telemetry?: TickSchedulerTelemetryConfig\n}\n\nexport interface TickSchedulerTelemetryEvent {\n  readonly tickSeq: number\n  readonly stable: boolean\n  readonly degradeReason?: TickDegradeReason\n  readonly forcedMacrotask?: boolean\n  readonly scheduleReason?: TickScheduleReason\n  readonly microtaskChainDepth?: number\n  readonly deferredWorkCount?: number\n}\n\nexport interface TickSchedulerTelemetryConfig {\n  /** Sample rate in [0, 1]. Default: 0 (disabled). */\n  readonly sampleRate?: number\n  /** Called for ticks that are degraded (stable=false) and/or started on a forced macrotask boundary. */\n  readonly onTickDegraded?: (event: TickSchedulerTelemetryEvent) => void\n}\n\nexport interface TickScheduler {\n  readonly getTickSeq: () => number\n  readonly onModuleCommit: (commit: RuntimeStoreModuleCommit) => Effect.Effect<void, never, never>\n  readonly onSelectorChanged: (args: {\n    readonly moduleInstanceKey: ModuleInstanceKey\n    readonly selectorId: string\n    readonly priority: StateCommitPriority\n  }) => void\n  readonly flushNow: Effect.Effect<void, never, never>\n}\n\n// ---- Runtime.batch (sync boundary) ----\n\ntype BatchWaiter = { readonly resolve: () => void }\n\nlet batchDepth = 0\nconst batchWaiters = new Set<BatchWaiter>()\n\nexport const enterRuntimeBatch = (): void => {\n  batchDepth += 1\n}\n\nexport const exitRuntimeBatch = (): void => {\n  batchDepth = Math.max(0, batchDepth - 1)\n  if (batchDepth !== 0) return\n  const waiters = Array.from(batchWaiters)\n  batchWaiters.clear()\n  for (const w of waiters) {\n    try {\n      w.resolve()\n    } catch {\n      // best-effort\n    }\n  }\n}\n\nconst waitForBatchEndIfNeeded = (): Effect.Effect<void, never, never> =>\n  batchDepth === 0\n    ? Effect.void\n    : Effect.async<void, never>((resume, signal) => {\n\n    let done = false\n    const cleanup = () => {\n      if (done) return\n      done = true\n      batchWaiters.delete(waiter)\n      try {\n        signal.removeEventListener('abort', onAbort)\n      } catch {\n        // best-effort\n      }\n    }\n\n    const onAbort = () => {\n      cleanup()\n    }\n\n    const waiter: BatchWaiter = {\n      resolve: () => {\n        cleanup()\n        resume(Effect.void)\n      },\n    }\n\n    batchWaiters.add(waiter)\n    try {\n      signal.addEventListener('abort', onAbort, { once: true })\n    } catch {\n      // best-effort\n    }\n  })\n\n// ---- TickScheduler implementation ----\n\ntype TriggerKind = 'externalStore' | 'dispatch' | 'timer' | 'unknown'\n\ntype TickScheduleStartedAs = 'microtask' | 'macrotask' | 'batch' | 'unknown'\ntype TickScheduleReason = 'budget' | 'cycle_detected' | 'microtask_starvation' | 'unknown'\n\ntype TickSchedule = {\n  readonly startedAs?: TickScheduleStartedAs\n  readonly microtaskChainDepth?: number\n  readonly forcedMacrotask?: boolean\n  readonly reason?: TickScheduleReason\n}\n\nconst clampSampleRate = (sampleRate: number | undefined): number => {\n  if (typeof sampleRate !== 'number' || !Number.isFinite(sampleRate)) return 0\n  if (sampleRate <= 0) return 0\n  if (sampleRate >= 1) return 1\n  return sampleRate\n}\n\nconst shouldSampleTick = (tickSeq: number, sampleRate: number): boolean => {\n  if (sampleRate <= 0) return false\n  if (sampleRate >= 1) return true\n  // Deterministic sampling: stable across runs, avoids Math.random() and keeps overhead minimal.\n  const x = tickSeq >>> 0\n  const h = Math.imul(x ^ 0x9e3779b9, 0x85ebca6b) >>> 0\n  return h / 0xffffffff < sampleRate\n}\n\nconst toTriggerKind = (originKind: string | undefined): TriggerKind => {\n  if (originKind === 'action') return 'dispatch'\n  if (originKind === 'trait-external-store') return 'externalStore'\n  if (originKind?.includes('timer')) return 'timer'\n  return 'unknown'\n}\n\nconst toLane = (priority: StateCommitPriority): TickLane => (priority === 'low' ? 'nonUrgent' : 'urgent')\n\nconst maxPriority = (a: StateCommitPriority, b: StateCommitPriority): StateCommitPriority =>\n  a === 'normal' || b === 'normal' ? 'normal' : 'low'\n\nconst mergeDrain = (base: RuntimeStorePendingDrain, next: RuntimeStorePendingDrain): RuntimeStorePendingDrain => {\n  const modules = new Map(base.modules)\n  for (const [k, commit] of next.modules) {\n    const prev = modules.get(k)\n    if (!prev) {\n      modules.set(k, commit)\n    } else {\n      modules.set(k, {\n        ...commit,\n        meta: {\n          ...commit.meta,\n          priority: maxPriority(prev.meta.priority, commit.meta.priority),\n        },\n      })\n    }\n  }\n\n  const dirtyTopics = new Map(base.dirtyTopics)\n  for (const [k, p] of next.dirtyTopics) {\n    const prev = dirtyTopics.get(k)\n    dirtyTopics.set(k, prev ? maxPriority(prev, p) : p)\n  }\n\n  return { modules, dirtyTopics }\n}\n\nconst emptyDrain = (): RuntimeStorePendingDrain => ({ modules: new Map(), dirtyTopics: new Map() })\n\nexport const makeTickScheduler = (args: {\n  readonly runtimeStore: RuntimeStore\n  readonly queue?: JobQueue\n  readonly hostScheduler: HostScheduler\n  readonly config?: TickSchedulerConfig\n  readonly declarativeLinkRuntime?: DeclarativeLinkRuntime\n}): TickScheduler => {\n  const store = args.runtimeStore\n  const hostScheduler = args.hostScheduler\n  const declarativeLinks = args.declarativeLinkRuntime\n  const queue = args.queue ?? makeJobQueue()\n\n  const config: Required<Pick<TickSchedulerConfig, 'maxSteps' | 'urgentStepCap' | 'maxDrainRounds' | 'microtaskChainDepthLimit'>> = {\n    maxSteps: args.config?.maxSteps ?? 64,\n    urgentStepCap: args.config?.urgentStepCap ?? 512,\n    maxDrainRounds: args.config?.maxDrainRounds ?? 8,\n    microtaskChainDepthLimit: args.config?.microtaskChainDepthLimit ?? 32,\n  }\n  const telemetry = args.config?.telemetry\n  const telemetrySampleRate = clampSampleRate(telemetry?.sampleRate)\n\n  let tickSeq = 0\n  let scheduled = false\n  let microtaskChainDepth = 0\n  let nextForcedReason: TickScheduleReason | undefined\n\n  let coalescedModules = 0\n  let coalescedTopics = 0\n\n  const yieldMicrotask = Effect.async<void, never>((resume) => {\n    hostScheduler.scheduleMicrotask(() => resume(Effect.void))\n  })\n  const yieldMacrotask = Effect.async<void, never>((resume, signal) => {\n    const cancel = hostScheduler.scheduleMacrotask(() => resume(Effect.void))\n    try {\n      signal.addEventListener(\n        'abort',\n        () => {\n          cancel()\n        },\n        { once: true },\n      )\n    } catch {\n      // best-effort\n    }\n  })\n\n  const scheduleTick = (): Effect.Effect<void, never, never> =>\n    Effect.gen(function* () {\n      if (scheduled) return\n      scheduled = true\n\n      const waitedForBatch = batchDepth > 0\n\n      const forcedReason = nextForcedReason\n      nextForcedReason = undefined\n\n      const shouldYieldForStarvation =\n        forcedReason == null && microtaskChainDepth >= Math.max(1, config.microtaskChainDepthLimit)\n\n      const reason: TickScheduleReason | undefined = forcedReason ?? (shouldYieldForStarvation ? 'microtask_starvation' : undefined)\n      const boundary: 'microtask' | 'macrotask' = reason ? 'macrotask' : 'microtask'\n      const startedAs: TickScheduleStartedAs = waitedForBatch ? 'batch' : boundary\n      const depthAtSchedule = microtaskChainDepth\n\n      yield* Effect.forkDaemon(\n        Effect.locally(TaskRunner.inSyncTransactionFiber, false)(\n          Effect.gen(function* () {\n            try {\n              yield* waitForBatchEndIfNeeded()\n              if (boundary === 'microtask') {\n                yield* yieldMicrotask\n                microtaskChainDepth += 1\n              } else {\n                yield* yieldMacrotask\n                microtaskChainDepth = 0\n              }\n\n              const schedule: TickSchedule = {\n                startedAs,\n                microtaskChainDepth: boundary === 'macrotask' ? depthAtSchedule : microtaskChainDepth,\n                ...(boundary === 'macrotask' ? { forcedMacrotask: true, reason: reason ?? 'unknown' } : {}),\n              }\n\n              const outcome = yield* flushTick(schedule)\n              if (!outcome.stable) {\n                nextForcedReason =\n                  outcome.degradeReason === 'budget_steps'\n                    ? 'budget'\n                    : outcome.degradeReason === 'cycle_detected'\n                      ? 'cycle_detected'\n                      : 'unknown'\n              }\n            } finally {\n              scheduled = false\n              // If something was re-queued or arrived after commit, schedule the next tick (best-effort).\n              if (queue.hasPending()) {\n                yield* scheduleTick()\n              } else {\n                // Reset chain depth when the system becomes idle (avoid forcing a macrotask on the next unrelated tick).\n                microtaskChainDepth = 0\n              }\n            }\n          }),\n        ),\n      )\n    })\n\n  const flushTick = (schedule: TickSchedule): Effect.Effect<{ stable: boolean; degradeReason?: TickDegradeReason }, never, never> =>\n    Effect.gen(function* () {\n    if (!queue.hasPending()) {\n      return { stable: true }\n    }\n\n    tickSeq += 1\n    const currentTickSeq = tickSeq\n\n    const diagnosticsLevel = yield* FiberRef.get(Debug.currentDiagnosticsLevel)\n    const shouldEmitTrace = DevtoolsHub.isDevtoolsEnabled() && diagnosticsLevel !== 'off'\n\n    const captured: {\n      drainRounds: number\n      stable: boolean\n      degradeReason?: TickDegradeReason\n      deferred?: RuntimeStorePendingDrain\n      accepted: RuntimeStorePendingDrain\n    } = {\n      drainRounds: 0,\n      stable: true,\n      accepted: emptyDrain(),\n    }\n\n    // Fixpoint capture: drain -> apply declarative links -> drain (bounded by maxDrainRounds).\n    while (captured.drainRounds < config.maxDrainRounds) {\n      const drained = queue.drain()\n      if (!drained) break\n      captured.drainRounds += 1\n      captured.accepted = mergeDrain(captured.accepted, drained)\n\n      if (declarativeLinks && drained.modules.size > 0) {\n        const changedModuleInstanceKeys = Array.from(drained.modules.keys())\n        yield* declarativeLinks.applyForSources({\n          tickSeq: currentTickSeq,\n          acceptedModules: captured.accepted.modules,\n          changedModuleInstanceKeys,\n        })\n      }\n    }\n\n    if (queue.hasPending()) {\n      captured.stable = false\n      captured.degradeReason = 'cycle_detected'\n    }\n\n    // Budget enforcement (defer nonUrgent only; urgent may be cut only in cycle safety-break).\n    const urgentModules: Array<RuntimeStoreModuleCommit> = []\n    const nonUrgentModules: Array<RuntimeStoreModuleCommit> = []\n\n    for (const commit of captured.accepted.modules.values()) {\n      if (toLane(commit.meta.priority) === 'urgent') {\n        urgentModules.push(commit)\n      } else {\n        nonUrgentModules.push(commit)\n      }\n    }\n\n    const urgentCapExceeded = urgentModules.length > config.urgentStepCap\n    const urgentAccepted = urgentCapExceeded ? urgentModules.slice(0, config.urgentStepCap) : urgentModules\n    const urgentDeferred = urgentCapExceeded ? urgentModules.slice(config.urgentStepCap) : []\n\n    const nonUrgentBudget = Math.max(0, config.maxSteps)\n    const nonUrgentAccepted = urgentCapExceeded ? [] : nonUrgentModules.slice(0, nonUrgentBudget)\n    const nonUrgentDeferred = urgentCapExceeded ? nonUrgentModules : nonUrgentModules.slice(nonUrgentBudget)\n\n    if (urgentCapExceeded) {\n      captured.stable = false\n      captured.degradeReason = 'cycle_detected'\n    } else if (nonUrgentDeferred.length > 0) {\n      captured.stable = false\n      captured.degradeReason = captured.degradeReason ?? 'budget_steps'\n    }\n\n    const acceptedModules = new Map<ModuleInstanceKey, RuntimeStoreModuleCommit>()\n    const deferredModules = new Map<ModuleInstanceKey, RuntimeStoreModuleCommit>()\n\n    for (const c of urgentAccepted) acceptedModules.set(c.moduleInstanceKey, c)\n    for (const c of nonUrgentAccepted) acceptedModules.set(c.moduleInstanceKey, c)\n\n    for (const c of urgentDeferred) deferredModules.set(c.moduleInstanceKey, c)\n    for (const c of nonUrgentDeferred) deferredModules.set(c.moduleInstanceKey, c)\n\n    const acceptedTopics = new Map<string, StateCommitPriority>()\n    const deferredTopics = new Map<string, StateCommitPriority>()\n\n    for (const [topicKey, priority] of captured.accepted.dirtyTopics) {\n      const info = storeTopicToModuleInstanceKey(topicKey)\n      if (!info) continue\n      if (acceptedModules.has(info)) {\n        acceptedTopics.set(topicKey, priority)\n      } else if (deferredModules.has(info)) {\n        deferredTopics.set(topicKey, priority)\n      } else {\n        // Conservative default: treat unknown topics as accepted.\n        acceptedTopics.set(topicKey, priority)\n      }\n    }\n\n    const acceptedDrain: RuntimeStorePendingDrain = {\n      modules: acceptedModules,\n      dirtyTopics: acceptedTopics,\n    }\n\n    const deferredDrain: RuntimeStorePendingDrain | undefined =\n      deferredModules.size > 0 || deferredTopics.size > 0\n        ? {\n            modules: deferredModules,\n            dirtyTopics: deferredTopics,\n          }\n        : undefined\n\n    captured.deferred = deferredDrain\n\n    let startedAtMs: number | undefined\n    let triggerSummary: any | undefined\n    let anchor: any | undefined\n    let backlog: any | undefined\n    let result: any | undefined\n\n    if (shouldEmitTrace) {\n      startedAtMs = Date.now()\n\n      triggerSummary = (() => {\n        const triggers = Array.from(captured.accepted.modules.values())\n        const counts = new Map<TriggerKind, number>()\n        let primary: any = undefined\n        for (const t of triggers) {\n          const kind = toTriggerKind(t.meta.originKind)\n          counts.set(kind, (counts.get(kind) ?? 0) + 1)\n          if (!primary) {\n            primary = {\n              kind,\n              moduleId: t.moduleId,\n              instanceId: t.instanceId,\n              fieldPath: kind === 'externalStore' ? t.meta.originName : undefined,\n              actionTag: kind === 'dispatch' ? t.meta.originName : undefined,\n            }\n          }\n        }\n        return {\n          total: triggers.length,\n          kinds: Array.from(counts.entries()).map(([kind, count]) => ({ kind, count })),\n          primary,\n          coalescedCount: {\n            modules: coalescedModules,\n            topics: coalescedTopics,\n          },\n        }\n      })()\n\n      anchor = (() => {\n        const first = captured.accepted.modules.values().next().value as RuntimeStoreModuleCommit | undefined\n        if (!first) return undefined\n        return {\n          moduleId: first.moduleId,\n          instanceId: first.instanceId,\n          txnSeq: first.meta.txnSeq,\n          txnId: first.meta.txnId,\n          ...(typeof first.opSeq === 'number' ? { opSeq: first.opSeq } : null),\n        }\n      })()\n\n      backlog = (() => {\n        const deferredWork = captured.deferred\n        if (!deferredWork) return undefined\n        const pendingDeferredWork = deferredWork.modules.size + deferredWork.dirtyTopics.size\n\n        const deferredModulesList = Array.from(deferredWork.modules.values())\n        const pendingExternalInputs = deferredModulesList.filter((m) => toTriggerKind(m.meta.originKind) === 'externalStore').length\n\n        const primaryDeferred =\n          deferredModulesList.find((m) => toTriggerKind(m.meta.originKind) === 'externalStore') ?? deferredModulesList[0]\n        const kind = primaryDeferred ? toTriggerKind(primaryDeferred.meta.originKind) : 'unknown'\n\n        const deferredPrimary =\n          primaryDeferred != null\n            ? {\n                kind: kind === 'externalStore' ? ('externalStore' as const) : ('unknown' as const),\n                moduleId: primaryDeferred.moduleId,\n                instanceId: primaryDeferred.instanceId,\n                fieldPath: kind === 'externalStore' ? primaryDeferred.meta.originName : undefined,\n                storeId: undefined,\n              }\n            : undefined\n\n        return {\n          pendingExternalInputs,\n          pendingDeferredWork,\n          deferredPrimary,\n        }\n      })()\n\n      result = {\n        stable: captured.stable,\n        ...(captured.stable ? null : { degradeReason: captured.degradeReason ?? 'unknown' }),\n      } as const\n    }\n\n    if (shouldEmitTrace && schedule.forcedMacrotask && schedule.reason === 'microtask_starvation') {\n      yield* Debug.record({\n        type: 'warn:microtask-starvation',\n        moduleId: anchor?.moduleId,\n        instanceId: anchor?.instanceId,\n        tickSeq: currentTickSeq,\n        microtaskChainDepth: schedule.microtaskChainDepth,\n      })\n    }\n\n    if (shouldEmitTrace) {\n      yield* Debug.record({\n        type: 'trace:tick',\n        moduleId: anchor?.moduleId,\n        instanceId: anchor?.instanceId,\n        data: {\n          tickSeq: currentTickSeq,\n          phase: 'start',\n          timestampMs: startedAtMs!,\n          schedule,\n          triggerSummary,\n          anchors: anchor,\n          budget: {\n            maxSteps: config.maxSteps,\n            elapsedMs: 0,\n            steps: 0,\n            txnCount: acceptedModules.size,\n          },\n        },\n      })\n    }\n\n    if (!captured.stable && shouldEmitTrace) {\n      yield* Debug.record({\n        type: 'trace:tick',\n        moduleId: anchor?.moduleId,\n        instanceId: anchor?.instanceId,\n        data: {\n          tickSeq: currentTickSeq,\n          phase: 'budgetExceeded',\n          timestampMs: Date.now(),\n          schedule,\n          triggerSummary,\n          anchors: anchor,\n          budget: {\n            maxSteps: config.maxSteps,\n            elapsedMs: Math.max(0, Date.now() - startedAtMs!),\n            steps: config.maxSteps,\n            txnCount: acceptedModules.size,\n          },\n          backlog,\n          result,\n        },\n      })\n    }\n\n    // Requeue deferred backlog before committing the tick, so the next tick can pick it up.\n    if (deferredDrain) {\n      queue.requeue(deferredDrain)\n    }\n\n    const committed = store.commitTick({\n      tickSeq: currentTickSeq,\n      accepted: acceptedDrain,\n    })\n\n    // Notify changed topics after committing the snapshot token.\n    for (const { listeners } of committed.changedTopics.values()) {\n      for (const listener of listeners) {\n        try {\n          listener()\n        } catch {\n          // best-effort: never let a subscriber break the tick\n        }\n      }\n    }\n\n    if (!captured.stable && shouldEmitTrace && backlog?.deferredPrimary) {\n      const primary = backlog.deferredPrimary\n      if (primary.kind === 'externalStore') {\n        const moduleInstanceKey =\n          primary.moduleId && primary.instanceId ? (`${primary.moduleId}::${primary.instanceId}` as ModuleInstanceKey) : undefined\n        if (moduleInstanceKey && store.getModuleSubscriberCount(moduleInstanceKey) > 0) {\n          yield* Debug.record({\n            type: 'warn:priority-inversion',\n            moduleId: primary.moduleId,\n            instanceId: primary.instanceId,\n            tickSeq: currentTickSeq,\n            reason: 'deferredBacklog',\n          })\n        }\n      }\n    }\n\n    if (shouldEmitTrace) {\n      yield* Debug.record({\n        type: 'trace:tick',\n        moduleId: anchor?.moduleId,\n        instanceId: anchor?.instanceId,\n        data: {\n          tickSeq: currentTickSeq,\n          phase: 'settled',\n          timestampMs: Date.now(),\n          schedule,\n          triggerSummary,\n          anchors: anchor,\n          budget: {\n            maxSteps: config.maxSteps,\n            elapsedMs: Math.max(0, Date.now() - startedAtMs!),\n            steps: acceptedModules.size,\n            txnCount: acceptedModules.size,\n          },\n          backlog,\n          result,\n        },\n      })\n    }\n\n    if (telemetry?.onTickDegraded && (schedule.forcedMacrotask || !captured.stable) && shouldSampleTick(currentTickSeq, telemetrySampleRate)) {\n      try {\n        telemetry.onTickDegraded({\n          tickSeq: currentTickSeq,\n          stable: captured.stable,\n          degradeReason: captured.stable ? undefined : (captured.degradeReason ?? 'unknown'),\n          forcedMacrotask: schedule.forcedMacrotask,\n          scheduleReason: schedule.reason,\n          microtaskChainDepth: schedule.microtaskChainDepth,\n          deferredWorkCount: deferredDrain ? deferredDrain.modules.size + deferredDrain.dirtyTopics.size : 0,\n        })\n      } catch {\n        // best-effort: never let user telemetry break the tick\n      }\n    }\n    coalescedModules = 0\n    coalescedTopics = 0\n\n    return { stable: captured.stable, degradeReason: captured.degradeReason }\n  })\n\n  const flushNow: TickScheduler['flushNow'] = flushTick({ startedAs: 'unknown' }).pipe(Effect.asVoid)\n\n  const storeTopicToModuleInstanceKey = (topicKey: string): ModuleInstanceKey | undefined => {\n    const idx = topicKey.indexOf('::rq:')\n    if (idx > 0) {\n      return topicKey.slice(0, idx) as ModuleInstanceKey\n    }\n    if (topicKey.includes('::')) {\n      return topicKey as ModuleInstanceKey\n    }\n    return undefined\n  }\n\n  const onSelectorChanged: TickScheduler['onSelectorChanged'] = ({ moduleInstanceKey, selectorId, priority }) => {\n    const coalesced = queue.markTopicDirty(makeReadQueryTopicKey(moduleInstanceKey, selectorId), priority)\n    if (coalesced) coalescedTopics += 1\n  }\n\n  const onModuleCommit: TickScheduler['onModuleCommit'] = (commit) =>\n    Effect.gen(function* () {\n      const coalescedCommit = queue.enqueueModuleCommit(commit)\n      if (coalescedCommit) coalescedModules += 1\n      const coalescedTopic = queue.markTopicDirty(commit.moduleInstanceKey, commit.meta.priority)\n      if (coalescedTopic) coalescedTopics += 1\n      yield* scheduleTick()\n    })\n\n  return {\n    getTickSeq: () => tickSeq,\n    onModuleCommit,\n    onSelectorChanged,\n    flushNow,\n  }\n}\n", "import type { StateCommitPriority } from './module.js'\nimport type { ModuleInstanceKey, RuntimeStoreModuleCommit, RuntimeStorePendingDrain, TopicKey } from './RuntimeStore.js'\n\nexport interface JobQueue {\n  readonly hasPending: () => boolean\n  /** Returns true when the operation coalesced with an existing pending entry. */\n  readonly enqueueModuleCommit: (commit: RuntimeStoreModuleCommit) => boolean\n  /** Returns true when the operation coalesced with an existing pending entry. */\n  readonly markTopicDirty: (topicKey: TopicKey, priority: StateCommitPriority) => boolean\n  readonly drain: () => RuntimeStorePendingDrain | undefined\n  readonly requeue: (drain: RuntimeStorePendingDrain) => void\n}\n\nconst maxPriority = (a: StateCommitPriority, b: StateCommitPriority): StateCommitPriority =>\n  a === 'normal' || b === 'normal' ? 'normal' : 'low'\n\nexport const makeJobQueue = (): JobQueue => {\n  let pendingModules = new Map<ModuleInstanceKey, RuntimeStoreModuleCommit>()\n  let pendingDirtyTopics = new Map<TopicKey, StateCommitPriority>()\n\n  const hasPending = (): boolean => pendingModules.size > 0 || pendingDirtyTopics.size > 0\n\n  const enqueueModuleCommit = (commit: RuntimeStoreModuleCommit): boolean => {\n    const prev = pendingModules.get(commit.moduleInstanceKey)\n    if (!prev) {\n      pendingModules.set(commit.moduleInstanceKey, commit)\n      return false\n    }\n\n    pendingModules.set(commit.moduleInstanceKey, {\n      ...commit,\n      meta: {\n        ...commit.meta,\n        priority: maxPriority(prev.meta.priority, commit.meta.priority),\n      },\n    })\n    return true\n  }\n\n  const markTopicDirty = (topicKey: TopicKey, priority: StateCommitPriority): boolean => {\n    const prev = pendingDirtyTopics.get(topicKey)\n    pendingDirtyTopics.set(topicKey, prev ? maxPriority(prev, priority) : priority)\n    return prev != null\n  }\n\n  const drain = (): RuntimeStorePendingDrain | undefined => {\n    if (!hasPending()) return undefined\n    const drained: RuntimeStorePendingDrain = {\n      modules: pendingModules,\n      dirtyTopics: pendingDirtyTopics,\n    }\n    pendingModules = new Map()\n    pendingDirtyTopics = new Map()\n    return drained\n  }\n\n  const requeue = (drain: RuntimeStorePendingDrain): void => {\n    for (const [, commit] of drain.modules) {\n      enqueueModuleCommit(commit)\n    }\n    for (const [k, p] of drain.dirtyTopics) {\n      markTopicDirty(k, p)\n    }\n  }\n\n  return {\n    hasPending,\n    enqueueModuleCommit,\n    markTopicDirty,\n    drain,\n    requeue,\n  }\n}\n\n", "import { Cause, Effect, Fiber, FiberRef, Ref, Stream } from 'effect'\nimport * as Debug from './DebugSink.js'\nimport { isDevEnv } from './env.js'\nimport type * as Logic from './LogicMiddleware.js'\nimport type { AnyModuleShape, LogicEffect } from './module.js'\nimport type { RuntimeInternalsResolvedConcurrencyPolicy } from './RuntimeInternals.js'\nimport type { StateTxnOrigin } from './StateTransaction.js'\n\n/**\n * Prevents calling run*Task inside a \"synchronous transaction execution fiber\" (it would deadlock the txnQueue).\n *\n * - ModuleRuntime locally marks it as true while executing each transaction (dispatch/source-refresh/devtools/...).\n * - run*Task checks the flag on start: when true, it emits diagnostics only in dev/test and then no-ops.\n */\nexport const inSyncTransactionFiber = FiberRef.unsafeMake(false)\n\n/**\n * Force source.refresh:\n * - Default: when snapshot keyHash is unchanged and a non-idle snapshot already exists, refresh SHOULD be a no-op\n *   (avoid redundant IO/writeback).\n * - Exception: explicit refresh (manual refresh) / invalidation-driven refresh needs to \"re-fetch even with the same keyHash\".\n *\n * Note: use a FiberRef to locally pass \"whether this refresh is forced\", avoiding expanding the source refresh handler signature.\n */\nexport const forceSourceRefresh = FiberRef.unsafeMake(false)\n\n/**\n * Synchronous transaction window (process-level) marker:\n * - Used as a hard guard in \"non-Effect API\" entry points (e.g. Promise/async functions).\n * - FiberRef cannot reliably read the \"current fiber\" in such entry points, so we need a synchronous callstack-level marker.\n *\n * Note: if a transaction body incorrectly crosses async boundaries, this marker will be held longer; that is a severe violation.\n */\nlet inSyncTransactionGlobalDepth = 0\n\nexport const enterSyncTransaction = (): void => {\n  inSyncTransactionGlobalDepth += 1\n}\n\nexport const exitSyncTransaction = (): void => {\n  inSyncTransactionGlobalDepth = Math.max(0, inSyncTransactionGlobalDepth - 1)\n}\n\nexport const isInSyncTransaction = (): boolean => inSyncTransactionGlobalDepth > 0\n\nexport type TaskRunnerMode =\n  | 'task' // sequential\n  | 'parallel'\n  | 'latest'\n  | 'exhaust'\n\nexport type TaskStatus = 'idle' | 'pending' | 'running' | 'success' | 'failure' | 'interrupted'\n\nexport interface TaskExecution {\n  readonly taskId: number\n  readonly status: TaskStatus\n  readonly acceptedAt: number\n  readonly startedAt?: number\n  readonly endedAt?: number\n}\n\nexport interface TaskRunnerOrigins {\n  readonly pending?: StateTxnOrigin\n  readonly success?: StateTxnOrigin\n  readonly failure?: StateTxnOrigin\n}\n\ntype TaskHandler<Payload, Sh extends AnyModuleShape, R> =\n  | LogicEffect<Sh, R, void, never>\n  | ((payload: Payload) => LogicEffect<Sh, R, void, never>)\n\ntype TaskEffect<Payload, Sh extends AnyModuleShape, R, A, E> =\n  | LogicEffect<Sh, R, A, E>\n  | ((payload: Payload) => LogicEffect<Sh, R, A, E>)\n\nexport interface TaskRunnerConfig<Payload, Sh extends AnyModuleShape, R, A = void, E = never> {\n  /**\n   * Optional: trigger source name (e.g. actionTag / fieldPath), used as the default pending origin.name.\n   * - BoundApiRuntime may fill this in for onAction(\"xxx\") / traits.source.refresh(\"field\"), etc.\n   * - Other callers are not required to provide it.\n   */\n  readonly triggerName?: string\n\n  /**\n   * pending: synchronous state writes (loading=true / clearing errors, etc.), always a separate transaction entry.\n   * - Only executed for tasks that are accepted and actually started (ignored triggers in runExhaustTask do not run pending).\n   */\n  readonly pending?: TaskHandler<Payload, Sh, R>\n\n  /**\n   * effect: real IO / async work (must run outside the transaction window).\n   */\n  readonly effect: TaskEffect<Payload, Sh, R, A, E>\n\n  /**\n   * success: success writeback (separate transaction entry).\n   */\n  readonly success?: (result: A, payload: Payload) => LogicEffect<Sh, R, void, never>\n\n  /**\n   * failure: failure writeback (separate transaction entry).\n   *\n   * Note: takes a Cause to preserve defect/interrupt semantics; interrupts do not trigger failure writeback by default.\n   */\n  readonly failure?: (cause: Cause.Cause<E>, payload: Payload) => LogicEffect<Sh, R, void, never>\n\n  /**\n   * origin: optional override for the three transaction origins.\n   * - Default: pending.kind=\"task:pending\"; success/failure.kind=\"service-callback\".\n   */\n  readonly origin?: TaskRunnerOrigins\n\n  /**\n   * priority: reserved for future debugging/sorting; does not change transaction boundaries or concurrency semantics.\n   */\n  readonly priority?: number\n}\n\nexport interface TaskRunnerRuntime {\n  readonly moduleId?: string\n  readonly instanceId?: string\n  readonly runWithStateTransaction: (\n    origin: StateTxnOrigin,\n    body: () => Effect.Effect<void, never, any>,\n  ) => Effect.Effect<void, never, any>\n  readonly resolveConcurrencyPolicy?: () => Effect.Effect<RuntimeInternalsResolvedConcurrencyPolicy, never, any>\n}\n\nconst resolve = <Payload, Sh extends AnyModuleShape, R, A, E>(\n  eff: TaskEffect<Payload, Sh, R, A, E> | TaskHandler<Payload, Sh, R>,\n  payload: Payload,\n): any => (typeof eff === 'function' ? (eff as any)(payload) : eff)\n\nconst defaultOrigins = (triggerName: string | undefined): Required<TaskRunnerOrigins> => ({\n  pending: {\n    kind: 'task:pending',\n    name: triggerName,\n  },\n  success: {\n    kind: 'service-callback',\n    name: 'task:success',\n  },\n  failure: {\n    kind: 'service-callback',\n    name: 'task:failure',\n  },\n})\n\nexport const shouldNoopInSyncTransactionFiber = (options: {\n  readonly moduleId?: string\n  readonly instanceId?: string\n  readonly code: string\n  readonly severity: 'error' | 'warning' | 'info'\n  readonly message: string\n  readonly hint?: string\n  readonly actionTag?: string\n  readonly kind?: string\n}): Effect.Effect<boolean> =>\n  Effect.gen(function* () {\n    const inTxn = yield* FiberRef.get(inSyncTransactionFiber)\n    if (!inTxn) {\n      return false\n    }\n    // Always no-op regardless of env (otherwise we may deadlock); diagnostics are emitted only in dev/test.\n    if (isDevEnv()) {\n      yield* Debug.record({\n        type: 'diagnostic',\n        moduleId: options.moduleId,\n        instanceId: options.instanceId,\n        code: options.code,\n        severity: options.severity,\n        message: options.message,\n        hint: options.hint,\n        actionTag: options.actionTag,\n        kind: options.kind,\n      })\n    }\n    return true\n  })\n\nconst resolveConcurrencyLimit = (runtime: TaskRunnerRuntime): Effect.Effect<number | 'unbounded', never, any> =>\n  runtime.resolveConcurrencyPolicy\n    ? runtime.resolveConcurrencyPolicy().pipe(Effect.map((p) => p.concurrencyLimit))\n    : Effect.succeed(16)\n\nconst runTaskLifecycle = <Payload, Sh extends AnyModuleShape, R, A, E>(\n  payload: Payload,\n  runtime: TaskRunnerRuntime,\n  config: TaskRunnerConfig<Payload, Sh, R, A, E>,\n  getCanWriteBack?: Effect.Effect<boolean>,\n): Effect.Effect<void, never, Logic.Env<Sh, R>> =>\n  Effect.gen(function* () {\n    const noop = yield* shouldNoopInSyncTransactionFiber({\n      moduleId: runtime.moduleId,\n      instanceId: runtime.instanceId,\n      code: 'logic::invalid_usage',\n      severity: 'error',\n      message: 'run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).',\n      hint:\n        'Call run*Task from the run section of a watcher (e.g. $.onAction/$.onState/$.on); ' +\n        '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).',\n      kind: 'run_task_in_transaction',\n    })\n    if (noop) {\n      return\n    }\n\n    const defaults = defaultOrigins(config.triggerName)\n    const origins: Required<TaskRunnerOrigins> = {\n      pending: config.origin?.pending ?? defaults.pending,\n      success: config.origin?.success ?? defaults.success,\n      failure: config.origin?.failure ?? defaults.failure,\n    }\n\n    // 1) pending: separate transaction entry; once started it should not be interrupted by runLatest.\n    const pending = config.pending\n    if (pending) {\n      yield* Effect.uninterruptible(\n        runtime.runWithStateTransaction(origins.pending, () => Effect.asVoid(resolve(pending, payload))),\n      )\n    }\n\n    // 2) IO: runs outside the transaction window.\n    const io = resolve(config.effect, payload) as Effect.Effect<A, E, Logic.Env<Sh, R>>\n    const exit = yield* Effect.exit(io)\n\n    // 3) writeback: use the guard to confirm it's still the current task (runLatestTask).\n    if (getCanWriteBack) {\n      const ok = yield* getCanWriteBack\n      if (!ok) {\n        return\n      }\n    }\n\n    if (exit._tag === 'Success') {\n      const success = config.success\n      if (success) {\n        yield* runtime.runWithStateTransaction(origins.success, () => Effect.asVoid(success(exit.value, payload)))\n      }\n      return\n    }\n\n    // Failure: interruptions do not trigger failure writeback (e.g. runLatestTask cancellation, Scope ending).\n    const cause = exit.cause as Cause.Cause<E>\n    if (Cause.isInterrupted(cause)) {\n      return\n    }\n\n    const failure = config.failure\n    if (failure) {\n      yield* runtime.runWithStateTransaction(origins.failure, () => Effect.asVoid(failure(cause, payload)))\n    }\n  }).pipe(\n    // Watchers must not crash as a whole due to a single task failure: swallow errors, but keep them diagnosable.\n    Effect.catchAllCause((cause) =>\n      Debug.record({\n        type: 'diagnostic',\n        moduleId: runtime.moduleId,\n        instanceId: runtime.instanceId,\n        code: 'task_runner::unhandled_failure',\n        severity: 'error',\n        message: 'TaskRunner encountered an unhandled failure (pending/IO/writeback).',\n        hint: 'Add a failure writeback for this task or handle errors explicitly upstream; avoid fire-and-forget swallowing errors.',\n        actionTag: config.triggerName,\n        kind: 'task_runner_unhandled_failure',\n        trigger: {\n          kind: 'task',\n          name: config.triggerName,\n        },\n      }).pipe(Effect.zipRight(Effect.logError('TaskRunner error', cause))),\n    ),\n  ) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n\n/**\n * makeTaskRunner\uFF1A\n * - Reuses FlowRuntime concurrency semantics (sequential/parallel/latest/exhaust).\n * - Splits a single trigger into: pending (separate txn) \u2192 IO \u2192 success/failure (separate txn).\n */\nexport const makeTaskRunner = <Payload, Sh extends AnyModuleShape, R, A = void, E = never>(\n  stream: Stream.Stream<Payload>,\n  mode: TaskRunnerMode,\n  runtime: TaskRunnerRuntime,\n  config: TaskRunnerConfig<Payload, Sh, R, A, E>,\n): Effect.Effect<void, never, Logic.Env<Sh, R>> => {\n  if (mode === 'latest') {\n    return Effect.gen(function* () {\n      const taskIdRef = yield* Ref.make(0)\n      const currentFiberRef = yield* Ref.make<Fiber.RuntimeFiber<void, never> | undefined>(undefined)\n\n      const start = (payload: Payload) =>\n        Effect.gen(function* () {\n          const taskId = yield* Ref.updateAndGet(taskIdRef, (n) => n + 1)\n\n          const prev = yield* Ref.get(currentFiberRef)\n          if (prev) {\n            // Do not wait for the old fiber to fully end (avoid blocking new triggers); writeback is guarded by taskId.\n            yield* Fiber.interruptFork(prev)\n          }\n\n          const canWriteBack = Ref.get(taskIdRef).pipe(Effect.map((current) => current === taskId))\n\n          const fiber = yield* Effect.fork(\n            runTaskLifecycle<Payload, Sh, R, A, E>(payload, runtime, config, canWriteBack),\n          )\n\n          yield* Ref.set(currentFiberRef, fiber)\n        })\n\n      return yield* Stream.runForEach(stream, start)\n    })\n  }\n\n  if (mode === 'exhaust') {\n    return Effect.gen(function* () {\n      const concurrency = yield* resolveConcurrencyLimit(runtime)\n      const busyRef = yield* Ref.make(false)\n\n      const mapper = (payload: Payload) =>\n        Effect.gen(function* () {\n          const acquired = yield* Ref.modify(busyRef, (busy) =>\n            busy ? ([false, busy] as const) : ([true, true] as const),\n          )\n          if (!acquired) {\n            // Ignore trigger: no pending transaction is produced.\n            return\n          }\n          try {\n            yield* runTaskLifecycle<Payload, Sh, R, A, E>(payload, runtime, config)\n          } finally {\n            yield* Ref.set(busyRef, false)\n          }\n        })\n\n      return yield* Stream.runDrain(stream.pipe(Stream.mapEffect(mapper, { concurrency })))\n    }) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n  }\n\n  if (mode === 'parallel') {\n    return Effect.gen(function* () {\n      const concurrency = yield* resolveConcurrencyLimit(runtime)\n\n      return yield* Stream.runDrain(\n        stream.pipe(\n          Stream.mapEffect((payload) => runTaskLifecycle<Payload, Sh, R, A, E>(payload, runtime, config), {\n            concurrency,\n          }),\n        ),\n      )\n    }) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n  }\n\n  // mode === \"task\"\uFF08sequential\uFF09\n  return Stream.runForEach(stream, (payload) =>\n    runTaskLifecycle<Payload, Sh, R, A, E>(payload, runtime, config),\n  ) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n}\n", "import { Context, Effect, Layer } from 'effect'\nimport type { TraitConvergeRequestedMode } from '../../state-trait/model.js'\nimport type { ReadQueryStrictGateConfig } from './ReadQuery.js'\nimport { getGlobalHostScheduler, type HostScheduler } from './HostScheduler.js'\nimport { makeRuntimeStore, type RuntimeStore } from './RuntimeStore.js'\nimport { makeTickScheduler, type TickScheduler, type TickSchedulerConfig } from './TickScheduler.js'\nimport { makeDeclarativeLinkRuntime, type DeclarativeLinkRuntime } from './DeclarativeLinkRuntime.js'\n\n// Unified runtime env detection, avoiding bundlers inlining NODE_ENV at build time.\nexport const getNodeEnv = (): string | undefined => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const env = (globalThis as any)?.process?.env\n    return typeof env?.NODE_ENV === 'string' ? env.NODE_ENV : undefined\n  } catch {\n    return undefined\n  }\n}\n\nexport const isDevEnv = (): boolean => getNodeEnv() !== 'production'\n\nexport type StateTransactionInstrumentation = 'full' | 'light'\n\n/**\n * getDefaultStateTxnInstrumentation\uFF1A\n * - Currently chooses default instrumentation by NODE_ENV:\n *   - dev / test: full (keep patches and snapshots for debugging).\n *   - production: light (keep minimal semantics to reduce overhead).\n * - May evolve with finer-grained overrides in Runtime.make / Module.make.\n */\nexport const getDefaultStateTxnInstrumentation = (): StateTransactionInstrumentation => (isDevEnv() ? 'full' : 'light')\n\n/**\n * Runtime-level StateTransaction config Service:\n * - Provided at the app layer by Logix.Runtime.make / AppRuntime.makeApp.\n * - ModuleRuntime.make can read runtime-level defaults from Env.\n *\n * Notes:\n * - instrumentation is only a runtime-level default.\n * - Explicit instrumentation in ModuleImpl / ModuleRuntimeOptions has higher priority.\n */\nexport interface StateTransactionRuntimeConfig {\n  readonly instrumentation?: StateTransactionInstrumentation\n  /**\n   * StateTrait derived converge budget (ms):\n   * - Exceeding the budget triggers a soft degrade (freeze derived fields, preserve base writes and 0/1 commit semantics).\n   * - Default is 200ms (aligned with the 007 spec threshold).\n   */\n  readonly traitConvergeBudgetMs?: number\n  /**\n   * Auto-mode decision budget (ms):\n   * - Only used during the decision phase when requestedMode=\"auto\".\n   * - Exceeding the budget must immediately fall back to full (and record evidence).\n   */\n  readonly traitConvergeDecisionBudgetMs?: number\n  /**\n   * StateTrait converge scheduling strategy:\n   * - full: full topo execution (current default; safest).\n   * - dirty: minimal triggering based on dirtyPaths + deps in the txn window (requires accurate deps).\n   */\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  /**\n   * 043: Trait converge time-slicing (explicit opt-in). Disabled by default.\n   */\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  /**\n   * 060: Txn Lanes (priority scheduling for transaction follow-up work). Enabled by default since 062.\n   */\n  readonly txnLanes?: TxnLanesPatch\n  /**\n   * Runtime-level per-module overrides (hotfix path):\n   * - Only affects converge behavior for the specified moduleId.\n   * - Lower priority than Provider overrides.\n   */\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /**\n   * 060: Txn Lanes runtime_module overrides (hotfix / gradual tuning).\n   * - Only affects the specified moduleId.\n   * - Lower priority than Provider overrides.\n   */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionConfigTagImpl extends Context.Tag('@logixjs/core/StateTransactionRuntimeConfig')<\n  StateTransactionConfigTagImpl,\n  StateTransactionRuntimeConfig\n>() {}\n\nexport const StateTransactionConfigTag = StateTransactionConfigTagImpl\n\nexport type ReadQueryStrictGateRuntimeConfig = ReadQueryStrictGateConfig\n\nclass ReadQueryStrictGateConfigTagImpl extends Context.Tag('@logixjs/core/ReadQueryStrictGateRuntimeConfig')<\n  ReadQueryStrictGateConfigTagImpl,\n  ReadQueryStrictGateRuntimeConfig\n>() {}\n\nexport const ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl\n\nexport type ReplayMode = 'live' | 'replay'\n\nexport interface ReplayModeConfig {\n  readonly mode: ReplayMode\n}\n\nclass ReplayModeConfigTagImpl extends Context.Tag('@logixjs/core/ReplayModeConfig')<\n  ReplayModeConfigTagImpl,\n  ReplayModeConfig\n>() {}\n\nexport const ReplayModeConfigTag = ReplayModeConfigTagImpl\n\nexport const replayModeLayer = (mode: ReplayMode): Layer.Layer<ReplayModeConfigTagImpl, never, never> =>\n  Layer.succeed(ReplayModeConfigTag, { mode })\n\nexport interface StateTransactionTraitConvergeOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n}\n\nexport interface TxnLanesPatch {\n  /**\n   * enabled: whether Txn Lanes is enabled (default on since 062).\n   * - undefined: default enabled (when not explicitly configured)\n   * - false: disabled (returns to baseline behavior)\n   * - true: enabled (only affects scheduling of follow-up work outside the transaction; transactions remain synchronous)\n   */\n  readonly enabled?: boolean\n  /**\n   * overrideMode: runtime temporary override (for debugging/rollback/comparison).\n   * - forced_off: forcibly disables Txn Lanes (returns to baseline behavior).\n   * - forced_sync: forces fully synchronous execution (ignores non-urgent deferral and time-slicing; used for comparisons).\n   *\n   * Notes:\n   * - Override precedence follows StateTransactionOverrides: provider > runtime_module > runtime_default > builtin.\n   * - Overrides must be explainable by evidence (see 060 LaneEvidence reasons).\n   */\n  readonly overrideMode?: 'forced_off' | 'forced_sync'\n  /** non-urgent work loop slice budget (ms). */\n  readonly budgetMs?: number\n  /** Non-urgent backlog coalescing window (ms). */\n  readonly debounceMs?: number\n  /** Max lag upper bound (ms): exceeding it triggers an explainable starvation protection (forced catch-up). */\n  readonly maxLagMs?: number\n  /** Whether to allow coalescing/canceling intermediate non-urgent work (must preserve eventual consistency). */\n  readonly allowCoalesce?: boolean\n  /**\n   * Yield strategy for the non-urgent work loop (progressive enhancement).\n   * - baseline: uses only time budget + hard upper bound\n   * - inputPending: when supported by browsers, also consults `navigator.scheduling.isInputPending`\n   */\n  readonly yieldStrategy?: 'baseline' | 'inputPending'\n}\n\nexport interface TraitConvergeTimeSlicingPatch {\n  /**\n   * enabled\uFF1A\n   * - false/undefined: disabled (default)\n   * - true: enables time-slicing (only affects computed/link explicitly marked as deferred)\n   */\n  readonly enabled?: boolean\n  /**\n   * debounceMs: coalescing interval (ms) for the deferral window; merges high-frequency inputs into one deferred flush.\n   */\n  readonly debounceMs?: number\n  /**\n   * maxLagMs: max lag upper bound (ms); exceeding it triggers an explainable forced flush (starvation protection).\n   */\n  readonly maxLagMs?: number\n}\n\n/**\n * Provider-scoped StateTransactionOverrides (delta overrides):\n * - Used to inject more local overrides into a Provider subtree on top of inherited global runtime config.\n * - Override precedence: provider > runtime_module > runtime_default > builtin.\n */\nexport interface StateTransactionOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /** 060: Txn Lanes provider-level overrides (delta overrides). */\n  readonly txnLanes?: TxnLanesPatch\n  /** 060: Txn Lanes provider_module overrides (by moduleId). */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionOverridesTagImpl extends Context.Tag('@logixjs/core/StateTransactionOverrides')<\n  StateTransactionOverridesTagImpl,\n  StateTransactionOverrides\n>() {}\n\nexport const StateTransactionOverridesTag = StateTransactionOverridesTagImpl\n\nexport type ConcurrencyLimit = number | 'unbounded'\n\nexport interface ConcurrencyPolicyPatch {\n  readonly concurrencyLimit?: ConcurrencyLimit\n  readonly losslessBackpressureCapacity?: number\n  readonly allowUnbounded?: boolean\n  readonly pressureWarningThreshold?: {\n    readonly backlogCount?: number\n    readonly backlogDurationMs?: number\n  }\n  readonly warningCooldownMs?: number\n}\n\n/**\n * Runtime-level ConcurrencyPolicy:\n * - Provided at the app layer by Logix.Runtime.make / AppRuntime.makeApp.\n * - ModuleRuntime merges sources via a resolver (builtin/runtime_module/provider, etc.).\n *\n * Notes:\n * - overridesByModuleId is used for runtime_module hot-switching (hotfix / gradual tuning) and is lower priority than provider overrides.\n */\nexport interface ConcurrencyPolicy extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyTagImpl extends Context.Tag('@logixjs/core/ConcurrencyPolicy')<\n  ConcurrencyPolicyTagImpl,\n  ConcurrencyPolicy\n>() {}\n\nexport const ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl\n\n/**\n * Provider-scoped ConcurrencyPolicyOverrides (delta overrides):\n * - Used to inject more local overrides into a Provider subtree on top of inherited global runtime config.\n * - Override precedence: provider > runtime_module > runtime_default > builtin.\n */\nexport interface ConcurrencyPolicyOverrides extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyOverridesTagImpl extends Context.Tag('@logixjs/core/ConcurrencyPolicyOverrides')<\n  ConcurrencyPolicyOverridesTagImpl,\n  ConcurrencyPolicyOverrides\n>() {}\n\nexport const ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl\n\n// ---- 073: TickScheduler + RuntimeStore (injectable runtime services) ----\n\nexport interface RuntimeStoreService extends RuntimeStore {}\n\nexport class RuntimeStoreTag extends Context.Tag('@logixjs/core/RuntimeStore')<RuntimeStoreTag, RuntimeStoreService>() {}\n\nexport const runtimeStoreLayer: Layer.Layer<any, never, never> = Layer.scoped(\n  RuntimeStoreTag,\n  Effect.acquireRelease(\n    Effect.sync(() => makeRuntimeStore() as RuntimeStoreService),\n    (store) => Effect.sync(() => store.dispose()),\n  ),\n) as Layer.Layer<any, never, never>\n\nexport const runtimeStoreTestStubLayer = (store: RuntimeStoreService): Layer.Layer<any, never, never> =>\n  Layer.succeed(RuntimeStoreTag, store) as Layer.Layer<any, never, never>\n\nexport interface HostSchedulerService extends HostScheduler {}\n\nexport class HostSchedulerTag extends Context.Tag('@logixjs/core/HostScheduler')<\n  HostSchedulerTag,\n  HostSchedulerService\n>() {}\n\nexport const hostSchedulerLayer: Layer.Layer<any, never, never> = Layer.succeed(\n  HostSchedulerTag,\n  getGlobalHostScheduler() as HostSchedulerService,\n) as Layer.Layer<any, never, never>\n\nexport const hostSchedulerTestStubLayer = (scheduler: HostSchedulerService): Layer.Layer<any, never, never> =>\n  Layer.succeed(HostSchedulerTag, scheduler) as Layer.Layer<any, never, never>\n\nexport interface DeclarativeLinkRuntimeService extends DeclarativeLinkRuntime {}\n\nexport class DeclarativeLinkRuntimeTag extends Context.Tag('@logixjs/core/DeclarativeLinkRuntime')<\n  DeclarativeLinkRuntimeTag,\n  DeclarativeLinkRuntimeService\n>() {}\n\nexport const declarativeLinkRuntimeLayer: Layer.Layer<any, never, never> = Layer.succeed(\n  DeclarativeLinkRuntimeTag,\n  makeDeclarativeLinkRuntime() as DeclarativeLinkRuntimeService,\n) as Layer.Layer<any, never, never>\n\nexport const declarativeLinkRuntimeTestStubLayer = (\n  runtime: DeclarativeLinkRuntimeService,\n): Layer.Layer<any, never, never> => Layer.succeed(DeclarativeLinkRuntimeTag, runtime) as Layer.Layer<any, never, never>\n\nexport interface TickSchedulerService extends TickScheduler {}\n\nexport class TickSchedulerTag extends Context.Tag('@logixjs/core/TickScheduler')<TickSchedulerTag, TickSchedulerService>() {}\n\nexport const tickSchedulerLayer = (config?: TickSchedulerConfig): Layer.Layer<any, never, never> =>\n  Layer.effect(\n    TickSchedulerTag,\n    Effect.gen(function* () {\n      const store = yield* RuntimeStoreTag\n      const declarativeLinkRuntime = yield* DeclarativeLinkRuntimeTag\n      const hostScheduler = yield* HostSchedulerTag\n      return makeTickScheduler({ runtimeStore: store, declarativeLinkRuntime, hostScheduler, config }) as TickSchedulerService\n    }),\n  ) as Layer.Layer<any, never, never>\n\nexport const tickSchedulerTestStubLayer = (scheduler: TickSchedulerService): Layer.Layer<any, never, never> =>\n  Layer.succeed(TickSchedulerTag, scheduler) as Layer.Layer<any, never, never>\n", "import type { StateCommitMeta, StateCommitPriority } from './module.js'\n\nexport type ModuleInstanceKey = `${string}::${string}`\nexport type TopicKey = string\n\nexport type TopicKind = 'module' | 'readQuery'\n\nexport type TopicInfo =\n  | { readonly kind: 'module'; readonly moduleInstanceKey: ModuleInstanceKey }\n  | { readonly kind: 'readQuery'; readonly moduleInstanceKey: ModuleInstanceKey; readonly selectorId: string }\n\nexport const makeModuleInstanceKey = (moduleId: string, instanceId: string): ModuleInstanceKey =>\n  `${moduleId}::${instanceId}`\n\nexport const makeReadQueryTopicKey = (moduleInstanceKey: ModuleInstanceKey, selectorId: string): TopicKey =>\n  `${moduleInstanceKey}::rq:${selectorId}`\n\nexport const parseTopicKey = (topicKey: string): TopicInfo | undefined => {\n  const idx = topicKey.indexOf('::')\n  if (idx <= 0) return undefined\n\n  const moduleId = topicKey.slice(0, idx)\n  const rest = topicKey.slice(idx + 2)\n  if (rest.length === 0) return undefined\n\n  const idx2 = rest.indexOf('::')\n  if (idx2 < 0) {\n    return { kind: 'module', moduleInstanceKey: `${moduleId}::${rest}` }\n  }\n\n  const instanceId = rest.slice(0, idx2)\n  const suffix = rest.slice(idx2 + 2)\n  if (suffix.startsWith('rq:')) {\n    const selectorId = suffix.slice('rq:'.length)\n    if (selectorId.length === 0) return undefined\n    return {\n      kind: 'readQuery',\n      moduleInstanceKey: `${moduleId}::${instanceId}`,\n      selectorId,\n    }\n  }\n\n  return { kind: 'module', moduleInstanceKey: `${moduleId}::${instanceId}` }\n}\n\nexport interface RuntimeStoreModuleCommit {\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly moduleInstanceKey: ModuleInstanceKey\n  readonly state: unknown\n  readonly meta: StateCommitMeta\n  readonly opSeq?: number\n}\n\nexport interface RuntimeStorePendingDrain {\n  readonly modules: ReadonlyMap<ModuleInstanceKey, RuntimeStoreModuleCommit>\n  readonly dirtyTopics: ReadonlyMap<TopicKey, StateCommitPriority>\n}\n\nexport interface RuntimeStoreCommitResult {\n  readonly changedTopics: ReadonlyMap<TopicKey, { readonly priority: StateCommitPriority; readonly listeners: ReadonlyArray<() => void> }>\n}\n\nexport interface RuntimeStore {\n  // ---- React-facing sync snapshot APIs ----\n  readonly getTickSeq: () => number\n  readonly getModuleState: (moduleInstanceKey: ModuleInstanceKey) => unknown\n  readonly getTopicVersion: (topicKey: TopicKey) => number\n  readonly getTopicPriority: (topicKey: TopicKey) => StateCommitPriority\n  readonly subscribeTopic: (topicKey: TopicKey, listener: () => void) => () => void\n  readonly getTopicSubscriberCount: (topicKey: TopicKey) => number\n  readonly getModuleSubscriberCount: (moduleInstanceKey: ModuleInstanceKey) => number\n\n  // ---- Runtime integration ----\n  readonly registerModuleInstance: (args: {\n    readonly moduleId: string\n    readonly instanceId: string\n    readonly moduleInstanceKey: ModuleInstanceKey\n    readonly initialState: unknown\n  }) => void\n  readonly unregisterModuleInstance: (moduleInstanceKey: ModuleInstanceKey) => void\n\n  // ---- TickScheduler integration (internal) ----\n  readonly commitTick: (args: {\n    readonly tickSeq: number\n    readonly accepted: RuntimeStorePendingDrain\n  }) => RuntimeStoreCommitResult\n\n  readonly dispose: () => void\n}\n\nexport const makeRuntimeStore = (): RuntimeStore => {\n  let tickSeq = 0\n\n  // ---- Committed snapshot (read by React) ----\n  const moduleStates = new Map<ModuleInstanceKey, unknown>()\n  const topicVersions = new Map<TopicKey, number>()\n  const topicPriorities = new Map<TopicKey, StateCommitPriority>()\n\n  // ---- Subscriptions ----\n  const listenersByTopic = new Map<TopicKey, Set<() => void>>()\n  const subscriberCountByModule = new Map<ModuleInstanceKey, number>()\n\n  const getTopicVersion = (topicKey: TopicKey): number => topicVersions.get(topicKey) ?? 0\n  const getTopicPriority = (topicKey: TopicKey): StateCommitPriority => topicPriorities.get(topicKey) ?? 'normal'\n\n  const commitTopicBump = (topicKey: TopicKey, priority: StateCommitPriority): void => {\n    const prev = topicVersions.get(topicKey) ?? 0\n    topicVersions.set(topicKey, prev + 1)\n    topicPriorities.set(topicKey, priority)\n  }\n\n  const subscribeTopic = (topicKey: TopicKey, listener: () => void): (() => void) => {\n    const info = parseTopicKey(topicKey)\n    const existing = listenersByTopic.get(topicKey)\n    const set = existing ?? new Set<() => void>()\n    const alreadyHas = set.has(listener)\n    if (!alreadyHas) {\n      set.add(listener)\n    }\n    if (!existing) {\n      listenersByTopic.set(topicKey, set)\n    }\n\n    if (!alreadyHas && info) {\n      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0\n      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1)\n    }\n\n    return () => {\n      const current = listenersByTopic.get(topicKey)\n      if (!current) return\n      const deleted = current.delete(listener)\n      if (deleted && info) {\n        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0\n        const next = prev - 1\n        if (next <= 0) {\n          subscriberCountByModule.delete(info.moduleInstanceKey)\n        } else {\n          subscriberCountByModule.set(info.moduleInstanceKey, next)\n        }\n      }\n      if (current.size === 0) {\n        listenersByTopic.delete(topicKey)\n      }\n    }\n  }\n\n  const getTopicSubscriberCount = (topicKey: TopicKey): number => listenersByTopic.get(topicKey)?.size ?? 0\n  const getModuleSubscriberCount = (moduleInstanceKey: ModuleInstanceKey): number => subscriberCountByModule.get(moduleInstanceKey) ?? 0\n\n  const registerModuleInstance = (args: {\n    readonly moduleId: string\n    readonly instanceId: string\n    readonly moduleInstanceKey: ModuleInstanceKey\n    readonly initialState: unknown\n  }): void => {\n    moduleStates.set(args.moduleInstanceKey, args.initialState)\n    // Ensure the module topic exists with a stable baseline version/priority.\n    if (!topicVersions.has(args.moduleInstanceKey)) {\n      topicVersions.set(args.moduleInstanceKey, 0)\n      topicPriorities.set(args.moduleInstanceKey, 'normal')\n    }\n  }\n\n  const unregisterModuleInstance = (moduleInstanceKey: ModuleInstanceKey): void => {\n    moduleStates.delete(moduleInstanceKey)\n    // Keep topic versions by default (helps debugging). Subscribers are expected to detach on module destroy.\n  }\n\n  const commitTick = (args: { readonly tickSeq: number; readonly accepted: RuntimeStorePendingDrain }): RuntimeStoreCommitResult => {\n    tickSeq = args.tickSeq\n\n    for (const [key, commit] of args.accepted.modules) {\n      moduleStates.set(key, commit.state)\n    }\n\n    const changedTopics = new Map<TopicKey, { readonly priority: StateCommitPriority; readonly listeners: ReadonlyArray<() => void> }>()\n\n    for (const [topicKey, priority] of args.accepted.dirtyTopics) {\n      commitTopicBump(topicKey, priority)\n      const listeners = Array.from(listenersByTopic.get(topicKey) ?? [])\n      if (listeners.length > 0) {\n        changedTopics.set(topicKey, { priority, listeners })\n      }\n    }\n\n    return { changedTopics }\n  }\n\n  const getModuleState = (moduleInstanceKey: ModuleInstanceKey): unknown => moduleStates.get(moduleInstanceKey)\n\n  const dispose = (): void => {\n    moduleStates.clear()\n    topicVersions.clear()\n    topicPriorities.clear()\n    listenersByTopic.clear()\n    subscriberCountByModule.clear()\n  }\n\n  return {\n    getTickSeq: () => tickSeq,\n    getModuleState,\n    getTopicVersion,\n    getTopicPriority,\n    subscribeTopic,\n    getTopicSubscriberCount,\n    getModuleSubscriberCount,\n    registerModuleInstance,\n    unregisterModuleInstance,\n    commitTick,\n    dispose,\n  }\n}\n", "import { Effect } from 'effect'\nimport type { ReadQueryCompiled } from './ReadQuery.js'\nimport type { DeclarativeLinkIR, DeclarativeLinkNodeId } from './DeclarativeLinkIR.js'\nimport type { ModuleInstanceKey, RuntimeStoreModuleCommit } from './RuntimeStore.js'\n\nexport interface ModuleAsSourceLink {\n  readonly id: string\n  readonly sourceModuleInstanceKey: ModuleInstanceKey\n  readonly readQuery: ReadQueryCompiled<any, any>\n  readonly computeValue: (snapshot: unknown) => unknown\n  readonly equalsValue: (a: unknown, b: unknown) => boolean\n  readonly applyValue: (next: unknown) => Effect.Effect<void, never, never>\n}\n\nexport interface DeclarativeLinkRegistration {\n  readonly linkId: string\n  readonly ir: DeclarativeLinkIR\n  readonly readNodes: ReadonlyArray<{\n    readonly nodeId: DeclarativeLinkNodeId\n    readonly moduleInstanceKey: ModuleInstanceKey\n    readonly readQuery: ReadQueryCompiled<any, any>\n  }>\n  readonly dispatchNodes: ReadonlyArray<{\n    readonly nodeId: DeclarativeLinkNodeId\n    readonly dispatch: (payload: unknown) => Effect.Effect<void, never, never>\n  }>\n}\n\nexport interface DeclarativeLinkRuntime {\n  readonly registerModuleAsSourceLink: (link: ModuleAsSourceLink) => () => void\n  readonly registerDeclarativeLink: (link: DeclarativeLinkRegistration) => () => void\n  readonly applyForSources: (args: {\n    readonly tickSeq: number\n    readonly acceptedModules: ReadonlyMap<ModuleInstanceKey, RuntimeStoreModuleCommit>\n    readonly changedModuleInstanceKeys: ReadonlyArray<ModuleInstanceKey>\n  }) => Effect.Effect<{ readonly scheduled: boolean }, never, never>\n}\n\ntype StoredModuleAsSourceLink = ModuleAsSourceLink & {\n  hasValue: boolean\n  lastValue: unknown\n}\n\ntype StoredDeclarativeLink = DeclarativeLinkRegistration & {\n  readonly readNodeById: ReadonlyMap<string, { readonly nodeId: DeclarativeLinkNodeId; readonly moduleInstanceKey: ModuleInstanceKey; readonly readQuery: ReadQueryCompiled<any, any> }>\n  readonly dispatchNodeById: ReadonlyMap<string, { readonly nodeId: DeclarativeLinkNodeId; readonly dispatch: (payload: unknown) => Effect.Effect<void, never, never> }>\n  readonly dispatchTargetsByReadNode: ReadonlyMap<string, ReadonlyArray<DeclarativeLinkNodeId>>\n  readonly readNodeState: Map<string, { hasValue: boolean; lastValue: unknown }>\n}\n\nexport const makeDeclarativeLinkRuntime = (): DeclarativeLinkRuntime => {\n  const moduleAsSourceById = new Map<string, StoredModuleAsSourceLink>()\n  const moduleAsSourceIdsBySource = new Map<ModuleInstanceKey, Set<string>>()\n\n  const declarativeById = new Map<string, StoredDeclarativeLink>()\n  const declarativeReadNodesBySource = new Map<ModuleInstanceKey, Array<{ readonly linkId: string; readonly nodeId: DeclarativeLinkNodeId }>>()\n\n  const registerModuleAsSourceLink: DeclarativeLinkRuntime['registerModuleAsSourceLink'] = (link) => {\n    const stored: StoredModuleAsSourceLink = {\n      ...link,\n      hasValue: false,\n      lastValue: undefined,\n    }\n\n    moduleAsSourceById.set(link.id, stored)\n    const set = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey) ?? new Set<string>()\n    set.add(link.id)\n    moduleAsSourceIdsBySource.set(link.sourceModuleInstanceKey, set)\n\n    return () => {\n      moduleAsSourceById.delete(link.id)\n      const current = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey)\n      if (!current) return\n      current.delete(link.id)\n      if (current.size === 0) {\n        moduleAsSourceIdsBySource.delete(link.sourceModuleInstanceKey)\n      }\n    }\n  }\n\n  const registerDeclarativeLink: DeclarativeLinkRuntime['registerDeclarativeLink'] = (link) => {\n    const readNodeById = new Map<string, { readonly nodeId: DeclarativeLinkNodeId; readonly moduleInstanceKey: ModuleInstanceKey; readonly readQuery: ReadQueryCompiled<any, any> }>()\n    for (const n of link.readNodes) {\n      readNodeById.set(n.nodeId, n)\n    }\n\n    const dispatchNodeById = new Map<\n      string,\n      { readonly nodeId: DeclarativeLinkNodeId; readonly dispatch: (payload: unknown) => Effect.Effect<void, never, never> }\n    >()\n    for (const n of link.dispatchNodes) {\n      dispatchNodeById.set(n.nodeId, n)\n    }\n\n    // V1 constraint: dispatch must have at most one incoming edge, interpreted as \"payload flow\".\n    const incomingByDispatch = new Map<string, number>()\n    for (const e of link.ir.edges) {\n      const to = e.to\n      const isDispatch = dispatchNodeById.has(to)\n      if (!isDispatch) continue\n      incomingByDispatch.set(to, (incomingByDispatch.get(to) ?? 0) + 1)\n      const count = incomingByDispatch.get(to) ?? 0\n      if (count > 1) {\n        throw new Error(\n          `[DeclarativeLinkRuntime] Invalid DeclarativeLinkIR: dispatch node has multiple incoming edges (linkId=${link.linkId}, nodeId=${to}).`,\n        )\n      }\n    }\n\n    const dispatchTargetsByReadNode = new Map<string, Array<DeclarativeLinkNodeId>>()\n    for (const e of link.ir.edges) {\n      const from = e.from\n      const to = e.to\n      if (!readNodeById.has(from)) continue\n      if (!dispatchNodeById.has(to)) continue\n      const list = dispatchTargetsByReadNode.get(from) ?? []\n      list.push(to)\n      dispatchTargetsByReadNode.set(from, list)\n    }\n\n    const stored: StoredDeclarativeLink = {\n      ...link,\n      readNodeById,\n      dispatchNodeById,\n      dispatchTargetsByReadNode,\n      readNodeState: new Map(),\n    }\n\n    declarativeById.set(link.linkId, stored)\n\n    for (const n of link.readNodes) {\n      const list = declarativeReadNodesBySource.get(n.moduleInstanceKey) ?? []\n      list.push({ linkId: link.linkId, nodeId: n.nodeId })\n      declarativeReadNodesBySource.set(n.moduleInstanceKey, list)\n    }\n\n    return () => {\n      declarativeById.delete(link.linkId)\n      for (const n of link.readNodes) {\n        const list = declarativeReadNodesBySource.get(n.moduleInstanceKey)\n        if (!list) continue\n        const next = list.filter((x) => !(x.linkId === link.linkId && x.nodeId === n.nodeId))\n        if (next.length === 0) {\n          declarativeReadNodesBySource.delete(n.moduleInstanceKey)\n        } else {\n          declarativeReadNodesBySource.set(n.moduleInstanceKey, next)\n        }\n      }\n    }\n  }\n\n  const applyForSources: DeclarativeLinkRuntime['applyForSources'] = (args) =>\n    Effect.gen(function* () {\n      let scheduled = false\n\n      // ---- Module-as-Source edges (module readQuery -> externalStore trait writeback) ----\n      for (const sourceKey of args.changedModuleInstanceKeys) {\n        const ids = moduleAsSourceIdsBySource.get(sourceKey)\n        if (!ids || ids.size === 0) continue\n        const commit = args.acceptedModules.get(sourceKey)\n        if (!commit) continue\n\n        for (const id of ids) {\n          const link = moduleAsSourceById.get(id)\n          if (!link) continue\n\n          let selected: unknown\n          try {\n            selected = link.readQuery.select(commit.state as any)\n          } catch {\n            continue\n          }\n\n          const nextValue = link.computeValue(selected)\n          if (link.hasValue && link.equalsValue(link.lastValue, nextValue)) {\n            continue\n          }\n\n          link.hasValue = true\n          link.lastValue = nextValue\n          scheduled = true\n          yield* link.applyValue(nextValue)\n        }\n      }\n\n      // ---- DeclarativeLinkIR edges (module readQuery -> dispatch) ----\n      for (const sourceKey of args.changedModuleInstanceKeys) {\n        const refs = declarativeReadNodesBySource.get(sourceKey)\n        if (!refs || refs.length === 0) continue\n        const commit = args.acceptedModules.get(sourceKey)\n        if (!commit) continue\n\n        for (const ref of refs) {\n          const link = declarativeById.get(ref.linkId)\n          if (!link) continue\n          const readNode = link.readNodeById.get(ref.nodeId)\n          if (!readNode) continue\n\n          let value: unknown\n          try {\n            value = readNode.readQuery.select(commit.state as any)\n          } catch {\n            continue\n          }\n\n          const state = link.readNodeState.get(ref.nodeId) ?? { hasValue: false, lastValue: undefined }\n          const changed = !state.hasValue || !Object.is(state.lastValue, value)\n          if (!changed) continue\n\n          state.hasValue = true\n          state.lastValue = value\n          link.readNodeState.set(ref.nodeId, state)\n\n          const targets = link.dispatchTargetsByReadNode.get(ref.nodeId) ?? []\n          for (const dispatchNodeId of targets) {\n            const node = link.dispatchNodeById.get(dispatchNodeId)\n            if (!node) continue\n            scheduled = true\n            yield* node.dispatch(value)\n          }\n        }\n      }\n\n      return { scheduled } as const\n    })\n\n  return {\n    registerModuleAsSourceLink,\n    registerDeclarativeLink,\n    applyForSources,\n  }\n}\n"],
  "mappings": "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",
  "names": ["Effect", "FiberRef", "drain", "Effect", "FiberRef", "Effect", "listeners", "Effect", "Effect", "Effect", "FiberRef", "Effect", "Effect", "maxPriority", "FiberRef", "listeners"]
}
