@logixjs/core 0.0.1 → 0.0.2

package/dist/Runtime.cjs

@@ -35,6 +35,7 @@ __export(Runtime_exports, {
   DisposeTimeoutError: () => DisposeTimeoutError,
   MainError: () => MainError,
   applyTransactionSnapshot: () => applyTransactionSnapshot,
+  batch: () => batch,
   concurrencyPolicyOverridesLayer: () => concurrencyPolicyOverridesLayer,
   make: () => make7,
   openProgram: () => openProgram2,
@@ -44,51 +45,281 @@ __export(Runtime_exports, {
   stateTransactionOverridesLayer: () => stateTransactionOverridesLayer
 });
 module.exports = __toCommonJS(Runtime_exports);
-var import_effect58 = require("effect");
+var import_effect61 = require("effect");
 
 // src/internal/runtime/AppRuntime.ts
-var import_effect9 = require("effect");
+var import_effect12 = require("effect");
 
 // src/internal/runtime/core/env.ts
-var import_effect = require("effect");
-var getNodeEnv = () => {
+var import_effect8 = require("effect");
+
+// src/internal/runtime/core/HostScheduler.ts
+var noopCancel = () => {
+};
+var safeNowMs = () => {
+  const perf = globalThis.performance;
+  if (perf && typeof perf.now === "function") {
+    try {
+      const v = perf.now();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+    } catch {
+    }
+  }
+  return Date.now();
+};
+var safeQueueMicrotask = (cb) => {
+  const qm = globalThis.queueMicrotask;
+  if (typeof qm === "function") {
+    try {
+      qm(cb);
+      return;
+    } catch {
+    }
+  }
   try {
-    const env = globalThis?.process?.env;
-    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+    Promise.resolve().then(cb);
   } catch {
-    return void 0;
+    setTimeout(cb, 0);
   }
 };
-var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
-};
-var StateTransactionConfigTag = StateTransactionConfigTagImpl;
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
 };
-var ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl;
-var ReplayModeConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var makeMessageChannelMacrotask = () => {
+  const MC = globalThis.MessageChannel;
+  if (typeof MC !== "function") return void 0;
+  let channel;
+  try {
+    channel = new MC();
+  } catch {
+    return void 0;
+  }
+  const queue = [];
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    const tasks = queue.splice(0, queue.length);
+    for (const t of tasks) {
+      if (t.canceled) continue;
+      try {
+        t.cb();
+      } catch {
+      }
+    }
+  };
+  try {
+    channel.port1.onmessage = flush;
+  } catch {
+    return void 0;
+  }
+  const schedule = (cb) => {
+    const task = { canceled: false, cb };
+    queue.push(task);
+    if (!scheduled) {
+      scheduled = true;
+      try {
+        channel.port2.postMessage(void 0);
+      } catch {
+        scheduled = false;
+        return safeSetTimeout(0, cb);
+      }
+    }
+    return () => {
+      task.canceled = true;
+    };
+  };
+  return schedule;
+};
+var makeSetImmediateMacrotask = () => {
+  const si = globalThis.setImmediate;
+  const ci = globalThis.clearImmediate;
+  if (typeof si !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = si(cb);
+    } catch {
+      return safeSetTimeout(0, cb);
+    }
+    return () => {
+      if (typeof ci !== "function") return;
+      try {
+        ci(id);
+      } catch {
+      }
+    };
+  };
 };
-var StateTransactionOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var makeRaf = () => {
+  const raf = globalThis.requestAnimationFrame;
+  const cancel = globalThis.cancelAnimationFrame;
+  if (typeof raf !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = raf(cb);
+    } catch {
+      return noopCancel;
+    }
+    return () => {
+      if (typeof cancel !== "function") return;
+      try {
+        cancel(id);
+      } catch {
+      }
+    };
+  };
 };
-var StateTransactionOverridesTag = StateTransactionOverridesTagImpl;
-var ConcurrencyPolicyTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var makeDefaultHostScheduler = () => {
+  const macrotask = makeSetImmediateMacrotask() ?? makeMessageChannelMacrotask() ?? ((cb) => safeSetTimeout(0, cb));
+  const raf = makeRaf();
+  return {
+    nowMs: safeNowMs,
+    scheduleMicrotask: safeQueueMicrotask,
+    scheduleMacrotask: macrotask,
+    scheduleAnimationFrame: (cb) => raf?.(cb) ?? macrotask(cb),
+    scheduleTimeout: safeSetTimeout
+  };
 };
-var ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl;
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var globalHostScheduler;
+var getGlobalHostScheduler = () => {
+  globalHostScheduler ?? (globalHostScheduler = makeDefaultHostScheduler());
+  return globalHostScheduler;
 };
-var ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl;
 
-// src/internal/runtime/core/RootContext.ts
-var import_effect2 = require("effect");
-var RootContextTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RootContext")() {
+// src/internal/runtime/core/RuntimeStore.ts
+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, commit2] of args.accepted.modules) {
+      moduleStates.set(key, commit2.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
+  };
 };
-var RootContextTag = RootContextTagImpl;
 
-// src/internal/runtime/core/process/ProcessRuntime.ts
-var import_effect8 = require("effect");
+// src/internal/runtime/core/TickScheduler.ts
+var import_effect6 = require("effect");
 
-// src/internal/runtime/core/DebugSink.ts
-var import_effect5 = require("effect");
+// src/internal/runtime/core/DebugSink.record.ts
+var import_effect3 = require("effect");
 
 // src/internal/observability/jsonValue.ts
 var defaultOptions = {
@@ -179,11 +410,12 @@ var toJsonValueInternal = (input, options, stats, seen, depth) => {
     stats.nonSerializable += 1;
     return truncateString(String(input), options.maxStringLength, stats);
   }
-  const entries = Object.entries(input);
-  const limit = Math.min(entries.length, options.maxObjectKeys);
+  const keys = Object.keys(input).sort();
+  const limit = Math.min(keys.length, options.maxObjectKeys);
   const out = {};
   for (let i = 0; i < limit; i++) {
-    const [rawKey, rawValue] = entries[i];
+    const rawKey = keys[i];
+    const rawValue = input[rawKey];
     const key = truncateString(rawKey, options.maxStringLength, stats);
     if (rawValue === void 0) {
       stats.dropped += 1;
@@ -191,9 +423,9 @@ var toJsonValueInternal = (input, options, stats, seen, depth) => {
     }
     out[key] = toJsonValueInternal(rawValue, options, stats, seen, depth + 1);
   }
-  if (entries.length > limit) {
+  if (keys.length > limit) {
     stats.oversized += 1;
-    out.__truncatedKeys = entries.length - limit;
+    out.__truncatedKeys = keys.length - limit;
   }
   return out;
 };
@@ -252,7 +484,7 @@ var projectJsonValue = (input, options) => {
 };
 
 // src/internal/runtime/core/errorSummary.ts
-var import_effect3 = require("effect");
+var import_effect = require("effect");
 var truncate = (value, maxLen) => {
   if (value.length <= maxLen) return { value, truncated: false };
   return { value: value.slice(0, maxLen), truncated: true };
@@ -272,7 +504,7 @@ var getMessageFromUnknown = (cause) => {
     return cause.message;
   }
   try {
-    const pretty = import_effect3.Cause.pretty(cause, { renderErrorCause: true });
+    const pretty = import_effect.Cause.pretty(cause, { renderErrorCause: true });
     if (typeof pretty === "string" && pretty.length > 0) return pretty;
   } catch {
   }
@@ -325,9 +557,9 @@ var toSerializableErrorSummary = (cause, options) => {
 };
 
 // src/internal/runtime/core/EffectOpCore.ts
-var import_effect4 = require("effect");
-var currentLinkId = import_effect4.FiberRef.unsafeMake(void 0);
-var EffectOpMiddlewareTag = class extends import_effect4.Context.Tag("Logix/EffectOpMiddleware")() {
+var import_effect2 = require("effect");
+var currentLinkId = import_effect2.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect2.Context.Tag("Logix/EffectOpMiddleware")() {
 };
 var composeMiddleware = (stack) => {
   return (op) => stack.reduceRight(
@@ -336,8 +568,8 @@ var composeMiddleware = (stack) => {
   );
 };
 var runWithMiddleware = (op, stack) => {
-  return import_effect4.Effect.gen(function* () {
-    const existing = yield* import_effect4.FiberRef.get(currentLinkId);
+  return import_effect2.Effect.gen(function* () {
+    const existing = yield* import_effect2.FiberRef.get(currentLinkId);
     const metaLinkId = op.meta?.linkId;
     const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
     const nextOp = {
@@ -348,21 +580,21 @@ var runWithMiddleware = (op, stack) => {
       }
     };
     const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
-    return yield* import_effect4.Effect.locally(currentLinkId, linkId)(program);
+    return yield* import_effect2.Effect.locally(currentLinkId, linkId)(program);
   });
 };
 
-// src/internal/runtime/core/DebugSink.ts
-var currentDebugSinks = import_effect5.FiberRef.unsafeMake([]);
-var currentRuntimeLabel = import_effect5.FiberRef.unsafeMake(void 0);
-var currentTxnId = import_effect5.FiberRef.unsafeMake(void 0);
-var currentOpSeq = import_effect5.FiberRef.unsafeMake(void 0);
-var currentDiagnosticsLevel = import_effect5.FiberRef.unsafeMake("off");
-var currentTraitConvergeDiagnosticsSampling = import_effect5.FiberRef.unsafeMake({
+// src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = import_effect3.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect3.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect3.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect3.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect3.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect3.FiberRef.unsafeMake({
   sampleEveryN: 32,
   topK: 3
 });
-var traitConvergeDiagnosticsSampling = (config) => import_effect5.Layer.fiberRefLocallyScopedWith(currentTraitConvergeDiagnosticsSampling, () => config);
+var traitConvergeDiagnosticsSampling = (config) => import_effect3.Layer.fiberRefLocallyScopedWith(currentTraitConvergeDiagnosticsSampling, () => config);
 var nextGlobalEventSeq = 0;
 var nextEventSeq = () => {
   nextGlobalEventSeq += 1;
@@ -412,7 +644,7 @@ var lifecycleErrorLog = (event) => {
   const moduleId = event.moduleId ?? "unknown";
   const causePretty = (() => {
     try {
-      return import_effect5.Cause.pretty(event.cause, {
+      return import_effect3.Cause.pretty(event.cause, {
         renderErrorCause: true
       });
     } catch {
@@ -425,8 +657,8 @@ var lifecycleErrorLog = (event) => {
   })();
   const message = `[Logix][module=${moduleId}] lifecycle:error
 ${causePretty}`;
-  return import_effect5.Effect.logError(message).pipe(
-    import_effect5.Effect.annotateLogs({
+  return import_effect3.Effect.logError(message).pipe(
+    import_effect3.Effect.annotateLogs({
       "logix.moduleId": moduleId,
       "logix.event": "lifecycle:error",
       "logix.cause": causePretty
@@ -440,7 +672,7 @@ var diagnosticLog = (event) => {
 hint: ${event.hint}` : ""}`;
   const msg = `${header}
 ${detail}`;
-  const base = event.severity === "warning" ? import_effect5.Effect.logWarning(msg) : event.severity === "info" ? import_effect5.Effect.logInfo(msg) : import_effect5.Effect.logError(msg);
+  const base = event.severity === "warning" ? import_effect3.Effect.logWarning(msg) : event.severity === "info" ? import_effect3.Effect.logInfo(msg) : import_effect3.Effect.logError(msg);
   const annotations = {
     "logix.moduleId": moduleId,
     "logix.event": `diagnostic(${event.severity})`,
@@ -453,24 +685,24 @@ ${detail}`;
   if (event.actionTag) {
     annotations["logix.diagnostic.actionTag"] = event.actionTag;
   }
-  return base.pipe(import_effect5.Effect.annotateLogs(annotations));
+  return base.pipe(import_effect3.Effect.annotateLogs(annotations));
 };
-var noopLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, []);
+var noopLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, []);
 var errorOnlySink = {
-  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect5.Effect.void
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void
 };
-var errorOnlyLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var errorOnlyLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
 var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
 var consoleSink = {
-  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect5.Effect.logDebug({ debugEvent: event })
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event })
 };
-var consoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var consoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
 var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
 var renderBrowserConsoleEvent = (event) => {
   if (typeof event.type === "string" && event.type.startsWith("trace:")) {
     const moduleId = event.moduleId ?? "unknown";
     const type = event.type;
-    return import_effect5.Effect.sync(() => {
+    return import_effect3.Effect.sync(() => {
       console.groupCollapsed(
         "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
         "color:#6b7280;font-weight:bold",
@@ -490,7 +722,7 @@ var renderBrowserConsoleEvent = (event) => {
     const moduleId = event.moduleId ?? "unknown";
     const causePretty = (() => {
       try {
-        return import_effect5.Cause.pretty(event.cause, { renderErrorCause: true });
+        return import_effect3.Cause.pretty(event.cause, { renderErrorCause: true });
       } catch {
         try {
           return JSON.stringify(event.cause, null, 2);
@@ -501,10 +733,10 @@ var renderBrowserConsoleEvent = (event) => {
     })();
     const key = `${moduleId}|${causePretty}`;
     if (browserLifecycleSeen.has(key)) {
-      return import_effect5.Effect.void;
+      return import_effect3.Effect.void;
     }
     browserLifecycleSeen.add(key);
-    return import_effect5.Effect.sync(() => {
+    return import_effect3.Effect.sync(() => {
       console.groupCollapsed(
         "%c[Logix]%c lifecycle:error %c" + moduleId,
         "color:#ef4444;font-weight:bold",
@@ -526,10 +758,10 @@ hint: ${event.hint}` : ""}`;
     const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
     const key = `${moduleId}|${event.code}|${event.message}`;
     if (browserDiagnosticSeen.has(key)) {
-      return import_effect5.Effect.void;
+      return import_effect3.Effect.void;
     }
     browserDiagnosticSeen.add(key);
-    return import_effect5.Effect.sync(() => {
+    return import_effect3.Effect.sync(() => {
       console.groupCollapsed(
         "%c[Logix]%c " + label + "%c module=" + moduleId,
         "color:#6b7280;font-weight:bold",
@@ -546,32 +778,32 @@ hint: ${event.hint}` : ""}`;
       console.groupEnd();
     });
   }
-  return import_effect5.Effect.void;
+  return import_effect3.Effect.void;
 };
 var browserConsoleSink = {
   record: (event) => {
     if (!isBrowser) {
-      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect5.Effect.logDebug({ debugEvent: event });
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect3.Effect.logDebug({ debugEvent: event });
     }
     return renderBrowserConsoleEvent(event);
   }
 };
-var browserConsoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
 var browserDiagnosticConsoleSink = {
   record: (event) => {
     if (!isBrowser) {
-      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect5.Effect.void;
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect3.Effect.void;
     }
-    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect5.Effect.void;
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect3.Effect.void;
   }
 };
-var browserDiagnosticConsoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
-var browserPrettyLoggerLayer = import_effect5.Logger.replace(
-  import_effect5.Logger.defaultLogger,
-  import_effect5.Logger.prettyLogger({ mode: "browser", colors: true })
+var browserDiagnosticConsoleLayer = import_effect3.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect3.Logger.replace(
+  import_effect3.Logger.defaultLogger,
+  import_effect3.Logger.prettyLogger({ mode: "browser", colors: true })
 );
-var record = (event) => import_effect5.Effect.gen(function* () {
-  const sinks = yield* import_effect5.FiberRef.get(currentDebugSinks);
+var record = (event) => import_effect3.Effect.gen(function* () {
+  const sinks = yield* import_effect3.FiberRef.get(currentDebugSinks);
   if (isErrorOnlyOnlySinks(sinks)) {
     if (event.type === "lifecycle:error") {
       yield* lifecycleErrorLog(event);
@@ -581,11 +813,11 @@ var record = (event) => import_effect5.Effect.gen(function* () {
       if (event.severity !== "info") {
         yield* diagnosticLog(event);
       } else {
-        yield* import_effect5.Effect.void;
+        yield* import_effect3.Effect.void;
       }
       return;
     }
-    yield* import_effect5.Effect.void;
+    yield* import_effect3.Effect.void;
     return;
   }
   if (sinks.length === 0) {
@@ -594,7 +826,7 @@ var record = (event) => import_effect5.Effect.gen(function* () {
         yield* renderBrowserConsoleEvent(event);
         return;
       }
-      yield* import_effect5.Effect.void;
+      yield* import_effect3.Effect.void;
       return;
     }
     if (event.type === "lifecycle:error") {
@@ -605,11 +837,11 @@ var record = (event) => import_effect5.Effect.gen(function* () {
       yield* diagnosticLog(event);
       return;
     }
-    yield* import_effect5.Effect.void;
+    yield* import_effect3.Effect.void;
     return;
   }
   const enriched = event;
-  const diagnosticsLevel2 = yield* import_effect5.FiberRef.get(currentDiagnosticsLevel);
+  const diagnosticsLevel2 = yield* import_effect3.FiberRef.get(currentDiagnosticsLevel);
   let now;
   const getNow = () => {
     if (now === void 0) now = Date.now();
@@ -620,21 +852,21 @@ var record = (event) => import_effect5.Effect.gen(function* () {
     enriched.timestamp = getNow();
   }
   if (diagnosticsLevel2 !== "off" && enriched.runtimeLabel === void 0) {
-    const runtimeLabel2 = yield* import_effect5.FiberRef.get(currentRuntimeLabel);
+    const runtimeLabel2 = yield* import_effect3.FiberRef.get(currentRuntimeLabel);
     if (runtimeLabel2) {
       ;
       enriched.runtimeLabel = runtimeLabel2;
     }
   }
   if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
-    const txnId = yield* import_effect5.FiberRef.get(currentTxnId);
+    const txnId = yield* import_effect3.FiberRef.get(currentTxnId);
     if (txnId) {
       ;
       enriched.txnId = txnId;
     }
   }
   if (diagnosticsLevel2 !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
-    const linkId = yield* import_effect5.FiberRef.get(currentLinkId);
+    const linkId = yield* import_effect3.FiberRef.get(currentLinkId);
     if (linkId) {
       ;
       enriched.linkId = linkId;
@@ -644,7 +876,7 @@ var record = (event) => import_effect5.Effect.gen(function* () {
     yield* sinks[0].record(enriched);
     return;
   }
-  yield* import_effect5.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+  yield* import_effect3.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
 });
 var toRuntimeDebugEventRef = (event, options) => {
   const diagnosticsLevel2 = options?.diagnosticsLevel ?? "full";
@@ -907,10 +1139,83 @@ var toRuntimeDebugEventRef = (event, options) => {
         meta: metaProjection.value
       });
     }
+    case "warn:priority-inversion": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      } : {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
+    case "warn:microtask-starvation": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      } : {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
     default: {
       if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
         return void 0;
       }
+      if (event.type === "trace:tick") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          tickSeq: data?.tickSeq,
+          phase: data?.phase,
+          schedule: data?.schedule,
+          triggerSummary: data?.triggerSummary,
+          anchors: data?.anchors,
+          budget: data?.budget,
+          backlog: data?.backlog,
+          result: data?.result
+        } : {
+          data
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
       if (event.type === "trace:txn-lane") {
         const data = event.data;
         const evidence = data?.evidence ?? data;
@@ -1276,13 +1581,270 @@ var toRuntimeDebugEventRef = (event, options) => {
         meta: metaProjection.value
       });
     }
-  }
+  }
+};
+
+// src/internal/runtime/core/DevtoolsHub.ts
+var import_effect4 = require("effect");
+var instances = /* @__PURE__ */ new Map();
+var latestStates = /* @__PURE__ */ new Map();
+var latestTraitSummaries = /* @__PURE__ */ new Map();
+var instanceLabels = /* @__PURE__ */ new Map();
+var convergeStaticIrByDigest = /* @__PURE__ */ new Map();
+var liveInstanceKeys = /* @__PURE__ */ new Set();
+var exportBudget = {
+  dropped: 0,
+  oversized: 0
+};
+var lastRunTs = 0;
+var lastRunTsSeq = 0;
+var nextRunId = () => {
+  const ts = Date.now();
+  if (ts === lastRunTs) {
+    lastRunTsSeq += 1;
+  } else {
+    lastRunTs = ts;
+    lastRunTsSeq = 0;
+  }
+  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
+};
+var currentRunId = nextRunId();
+var nextSeq = 1;
+var bufferSize = 500;
+var ringBuffer = [];
+var ringBufferSeq = [];
+var snapshotToken = 0;
+var ensureRingBufferSize = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (ringBuffer.length <= bufferSize) return;
+  const excess = ringBuffer.length - bufferSize;
+  ringBuffer.splice(0, excess);
+  ringBufferSeq.splice(0, excess);
+};
+var trimRingBufferIfNeeded = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (bufferSize <= 64) {
+    ensureRingBufferSize();
+    return;
+  }
+  const slack = Math.min(1024, Math.floor(bufferSize / 2));
+  const threshold = bufferSize + Math.max(1, slack);
+  if (ringBuffer.length <= threshold) return;
+  const excess = ringBuffer.length - bufferSize;
+  ringBuffer.splice(0, excess);
+  ringBufferSeq.splice(0, excess);
+};
+var currentSnapshot = {
+  snapshotToken,
+  instances,
+  events: ringBuffer,
+  latestStates,
+  latestTraitSummaries,
+  exportBudget
+};
+var listeners = /* @__PURE__ */ new Set();
+var notifyScheduled = false;
+var scheduleNotify = () => {
+  if (listeners.size === 0) return;
+  if (notifyScheduled) return;
+  notifyScheduled = true;
+  getGlobalHostScheduler().scheduleMicrotask(() => {
+    notifyScheduled = false;
+    for (const listener of listeners) {
+      listener();
+    }
+  });
+};
+var devtoolsEnabled = false;
+var bumpSnapshotToken = () => {
+  snapshotToken += 1;
+  currentSnapshot.snapshotToken = snapshotToken;
+};
+var markSnapshotChanged = () => {
+  bumpSnapshotToken();
+  scheduleNotify();
+};
+var configureDevtoolsHub = (options) => {
+  devtoolsEnabled = true;
+  if (typeof options?.bufferSize === "number" && Number.isFinite(options.bufferSize)) {
+    const next = Math.floor(options.bufferSize);
+    const nextBufferSize = next >= 0 ? next : 0;
+    if (nextBufferSize !== bufferSize) {
+      bufferSize = nextBufferSize;
+      ensureRingBufferSize();
+      markSnapshotChanged();
+    }
+  }
+};
+var isDevtoolsEnabled = () => devtoolsEnabled;
+var registerConvergeStaticIr = (ir) => {
+  convergeStaticIrByDigest.set(ir.staticIrDigest, ir);
+};
+var devtoolsHubConvergeStaticIrCollector = {
+  register: registerConvergeStaticIr
+};
+var devtoolsHubSink = {
+  record: (event) => import_effect4.Effect.gen(function* () {
+    const level = yield* import_effect4.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 runtimeLabel2 = event.runtimeLabel ?? "unknown";
+      const instanceId = event.instanceId;
+      const key = `${runtimeLabel2}::${moduleId}`;
+      const prev = instances.get(key) ?? 0;
+      if (event.type === "module:init") {
+        instances.set(key, prev + 1);
+        changed = true;
+        if (instanceId) {
+          const instanceKey = `${runtimeLabel2}::${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 = `${runtimeLabel2}::${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 runtimeLabel2 = ref.runtimeLabel ?? "unknown";
+      const key = `${runtimeLabel2}::${ref.moduleId}::${ref.instanceId}`;
+      if (liveInstanceKeys.has(key)) {
+        if (ref.meta && typeof ref.meta === "object" && !Array.isArray(ref.meta)) {
+          const anyMeta = ref.meta;
+          if ("state" in anyMeta) {
+            latestStates.set(key, anyMeta.state);
+            changed = true;
+          }
+          if ("traitSummary" in anyMeta && anyMeta.traitSummary !== void 0) {
+            latestTraitSummaries.set(key, anyMeta.traitSummary);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (bufferSize > 0) {
+      const seq = nextSeq++;
+      ringBuffer.push(ref);
+      ringBufferSeq.push(seq);
+      trimRingBufferIfNeeded();
+      changed = true;
+    }
+    if (changed) {
+      markSnapshotChanged();
+    }
+  })
+};
+
+// src/internal/runtime/core/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 = (commit2) => {
+    const prev = pendingModules.get(commit2.moduleInstanceKey);
+    if (!prev) {
+      pendingModules.set(commit2.moduleInstanceKey, commit2);
+      return false;
+    }
+    pendingModules.set(commit2.moduleInstanceKey, {
+      ...commit2,
+      meta: {
+        ...commit2.meta,
+        priority: maxPriority(prev.meta.priority, commit2.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 [, commit2] of drain2.modules) {
+      enqueueModuleCommit(commit2);
+    }
+    for (const [k, p] of drain2.dirtyTopics) {
+      markTopicDirty(k, p);
+    }
+  };
+  return {
+    hasPending,
+    enqueueModuleCommit,
+    markTopicDirty,
+    drain,
+    requeue
+  };
 };
 
 // src/internal/runtime/core/TaskRunner.ts
-var import_effect6 = require("effect");
-var inSyncTransactionFiber = import_effect6.FiberRef.unsafeMake(false);
-var forceSourceRefresh = import_effect6.FiberRef.unsafeMake(false);
+var import_effect5 = require("effect");
+var inSyncTransactionFiber = import_effect5.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect5.FiberRef.unsafeMake(false);
 var inSyncTransactionGlobalDepth = 0;
 var isInSyncTransaction = () => inSyncTransactionGlobalDepth > 0;
 var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
@@ -1300,8 +1862,8 @@ var defaultOrigins = (triggerName) => ({
     name: "task:failure"
   }
 });
-var shouldNoopInSyncTransactionFiber = (options) => import_effect6.Effect.gen(function* () {
-  const inTxn = yield* import_effect6.FiberRef.get(inSyncTransactionFiber);
+var shouldNoopInSyncTransactionFiber = (options) => import_effect5.Effect.gen(function* () {
+  const inTxn = yield* import_effect5.FiberRef.get(inSyncTransactionFiber);
   if (!inTxn) {
     return false;
   }
@@ -1320,8 +1882,8 @@ var shouldNoopInSyncTransactionFiber = (options) => import_effect6.Effect.gen(fu
   }
   return true;
 });
-var resolveConcurrencyLimit = (runtime) => runtime.resolveConcurrencyPolicy ? runtime.resolveConcurrencyPolicy().pipe(import_effect6.Effect.map((p) => p.concurrencyLimit)) : import_effect6.Effect.succeed(16);
-var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_effect6.Effect.gen(function* () {
+var resolveConcurrencyLimit = (runtime) => runtime.resolveConcurrencyPolicy ? runtime.resolveConcurrencyPolicy().pipe(import_effect5.Effect.map((p) => p.concurrencyLimit)) : import_effect5.Effect.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_effect5.Effect.gen(function* () {
   const noop = yield* shouldNoopInSyncTransactionFiber({
     moduleId: runtime.moduleId,
     instanceId: runtime.instanceId,
@@ -1342,12 +1904,12 @@ var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_eff
   };
   const pending = config.pending;
   if (pending) {
-    yield* import_effect6.Effect.uninterruptible(
-      runtime.runWithStateTransaction(origins.pending, () => import_effect6.Effect.asVoid(resolve(pending, payload)))
+    yield* import_effect5.Effect.uninterruptible(
+      runtime.runWithStateTransaction(origins.pending, () => import_effect5.Effect.asVoid(resolve(pending, payload)))
     );
   }
   const io = resolve(config.effect, payload);
-  const exit = yield* import_effect6.Effect.exit(io);
+  const exit = yield* import_effect5.Effect.exit(io);
   if (getCanWriteBack) {
     const ok = yield* getCanWriteBack;
     if (!ok) {
@@ -1357,21 +1919,21 @@ var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_eff
   if (exit._tag === "Success") {
     const success = config.success;
     if (success) {
-      yield* runtime.runWithStateTransaction(origins.success, () => import_effect6.Effect.asVoid(success(exit.value, payload)));
+      yield* runtime.runWithStateTransaction(origins.success, () => import_effect5.Effect.asVoid(success(exit.value, payload)));
     }
     return;
   }
   const cause = exit.cause;
-  if (import_effect6.Cause.isInterrupted(cause)) {
+  if (import_effect5.Cause.isInterrupted(cause)) {
     return;
   }
   const failure = config.failure;
   if (failure) {
-    yield* runtime.runWithStateTransaction(origins.failure, () => import_effect6.Effect.asVoid(failure(cause, payload)));
+    yield* runtime.runWithStateTransaction(origins.failure, () => import_effect5.Effect.asVoid(failure(cause, payload)));
   }
 }).pipe(
   // Watchers must not crash as a whole due to a single task failure: swallow errors, but keep them diagnosable.
-  import_effect6.Effect.catchAllCause(
+  import_effect5.Effect.catchAllCause(
     (cause) => record({
       type: "diagnostic",
       moduleId: runtime.moduleId,
@@ -1386,35 +1948,35 @@ var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_eff
         kind: "task",
         name: config.triggerName
       }
-    }).pipe(import_effect6.Effect.zipRight(import_effect6.Effect.logError("TaskRunner error", cause)))
+    }).pipe(import_effect5.Effect.zipRight(import_effect5.Effect.logError("TaskRunner error", cause)))
   )
 );
 var makeTaskRunner = (stream, mode, runtime, config) => {
   if (mode === "latest") {
-    return import_effect6.Effect.gen(function* () {
-      const taskIdRef = yield* import_effect6.Ref.make(0);
-      const currentFiberRef = yield* import_effect6.Ref.make(void 0);
-      const start = (payload) => import_effect6.Effect.gen(function* () {
-        const taskId = yield* import_effect6.Ref.updateAndGet(taskIdRef, (n) => n + 1);
-        const prev = yield* import_effect6.Ref.get(currentFiberRef);
+    return import_effect5.Effect.gen(function* () {
+      const taskIdRef = yield* import_effect5.Ref.make(0);
+      const currentFiberRef = yield* import_effect5.Ref.make(void 0);
+      const start = (payload) => import_effect5.Effect.gen(function* () {
+        const taskId = yield* import_effect5.Ref.updateAndGet(taskIdRef, (n) => n + 1);
+        const prev = yield* import_effect5.Ref.get(currentFiberRef);
         if (prev) {
-          yield* import_effect6.Fiber.interruptFork(prev);
+          yield* import_effect5.Fiber.interruptFork(prev);
         }
-        const canWriteBack = import_effect6.Ref.get(taskIdRef).pipe(import_effect6.Effect.map((current) => current === taskId));
-        const fiber = yield* import_effect6.Effect.fork(
+        const canWriteBack = import_effect5.Ref.get(taskIdRef).pipe(import_effect5.Effect.map((current) => current === taskId));
+        const fiber = yield* import_effect5.Effect.fork(
           runTaskLifecycle(payload, runtime, config, canWriteBack)
         );
-        yield* import_effect6.Ref.set(currentFiberRef, fiber);
+        yield* import_effect5.Ref.set(currentFiberRef, fiber);
       });
-      return yield* import_effect6.Stream.runForEach(stream, start);
+      return yield* import_effect5.Stream.runForEach(stream, start);
     });
   }
   if (mode === "exhaust") {
-    return import_effect6.Effect.gen(function* () {
+    return import_effect5.Effect.gen(function* () {
       const concurrency = yield* resolveConcurrencyLimit(runtime);
-      const busyRef = yield* import_effect6.Ref.make(false);
-      const mapper = (payload) => import_effect6.Effect.gen(function* () {
-        const acquired = yield* import_effect6.Ref.modify(
+      const busyRef = yield* import_effect5.Ref.make(false);
+      const mapper = (payload) => import_effect5.Effect.gen(function* () {
+        const acquired = yield* import_effect5.Ref.modify(
           busyRef,
           (busy) => busy ? [false, busy] : [true, true]
         );
@@ -1424,30 +1986,725 @@ var makeTaskRunner = (stream, mode, runtime, config) => {
         try {
           yield* runTaskLifecycle(payload, runtime, config);
         } finally {
-          yield* import_effect6.Ref.set(busyRef, false);
+          yield* import_effect5.Ref.set(busyRef, false);
         }
       });
-      return yield* import_effect6.Stream.runDrain(stream.pipe(import_effect6.Stream.mapEffect(mapper, { concurrency })));
+      return yield* import_effect5.Stream.runDrain(stream.pipe(import_effect5.Stream.mapEffect(mapper, { concurrency })));
     });
   }
   if (mode === "parallel") {
-    return import_effect6.Effect.gen(function* () {
+    return import_effect5.Effect.gen(function* () {
       const concurrency = yield* resolveConcurrencyLimit(runtime);
-      return yield* import_effect6.Stream.runDrain(
+      return yield* import_effect5.Stream.runDrain(
         stream.pipe(
-          import_effect6.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
+          import_effect5.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
             concurrency
           })
         )
       );
     });
   }
-  return import_effect6.Stream.runForEach(
+  return import_effect5.Stream.runForEach(
     stream,
     (payload) => runTaskLifecycle(payload, runtime, config)
   );
 };
 
+// src/internal/runtime/core/TickScheduler.ts
+var batchDepth = 0;
+var batchWaiters = /* @__PURE__ */ new Set();
+var enterRuntimeBatch = () => {
+  batchDepth += 1;
+};
+var exitRuntimeBatch = () => {
+  batchDepth = Math.max(0, batchDepth - 1);
+  if (batchDepth !== 0) return;
+  const waiters = Array.from(batchWaiters);
+  batchWaiters.clear();
+  for (const w of waiters) {
+    try {
+      w.resolve();
+    } catch {
+    }
+  }
+};
+var waitForBatchEndIfNeeded = () => batchDepth === 0 ? import_effect6.Effect.void : import_effect6.Effect.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(import_effect6.Effect.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, commit2] of next.modules) {
+    const prev = modules.get(k);
+    if (!prev) {
+      modules.set(k, commit2);
+    } else {
+      modules.set(k, {
+        ...commit2,
+        meta: {
+          ...commit2.meta,
+          priority: maxPriority2(prev.meta.priority, commit2.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 = import_effect6.Effect.async((resume) => {
+    hostScheduler.scheduleMicrotask(() => resume(import_effect6.Effect.void));
+  });
+  const yieldMacrotask = import_effect6.Effect.async((resume, signal) => {
+    const cancel = hostScheduler.scheduleMacrotask(() => resume(import_effect6.Effect.void));
+    try {
+      signal.addEventListener(
+        "abort",
+        () => {
+          cancel();
+        },
+        { once: true }
+      );
+    } catch {
+    }
+  });
+  const scheduleTick = () => import_effect6.Effect.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* import_effect6.Effect.forkDaemon(
+      import_effect6.Effect.locally(inSyncTransactionFiber, false)(
+        import_effect6.Effect.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) => import_effect6.Effect.gen(function* () {
+    if (!queue.hasPending()) {
+      return { stable: true };
+    }
+    tickSeq += 1;
+    const currentTickSeq = tickSeq;
+    const diagnosticsLevel2 = yield* import_effect6.FiberRef.get(currentDiagnosticsLevel);
+    const shouldEmitTrace = isDevtoolsEnabled() && diagnosticsLevel2 !== "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 commit2 of captured.accepted.modules.values()) {
+      if (toLane(commit2.meta.priority) === "urgent") {
+        urgentModules.push(commit2);
+      } else {
+        nonUrgentModules.push(commit2);
+      }
+    }
+    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(import_effect6.Effect.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 = (commit2) => import_effect6.Effect.gen(function* () {
+    const coalescedCommit = queue.enqueueModuleCommit(commit2);
+    if (coalescedCommit) coalescedModules += 1;
+    const coalescedTopic = queue.markTopicDirty(commit2.moduleInstanceKey, commit2.meta.priority);
+    if (coalescedTopic) coalescedTopics += 1;
+    yield* scheduleTick();
+  });
+  return {
+    getTickSeq: () => tickSeq,
+    onModuleCommit,
+    onSelectorChanged,
+    flushNow
+  };
+};
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect7 = require("effect");
+var makeDeclarativeLinkRuntime = () => {
+  const moduleAsSourceById = /* @__PURE__ */ new Map();
+  const moduleAsSourceIdsBySource = /* @__PURE__ */ new Map();
+  const declarativeById = /* @__PURE__ */ new Map();
+  const declarativeReadNodesBySource = /* @__PURE__ */ new Map();
+  const registerModuleAsSourceLink = (link) => {
+    const stored = {
+      ...link,
+      hasValue: false,
+      lastValue: void 0
+    };
+    moduleAsSourceById.set(link.id, stored);
+    const set = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey) ?? /* @__PURE__ */ new Set();
+    set.add(link.id);
+    moduleAsSourceIdsBySource.set(link.sourceModuleInstanceKey, set);
+    return () => {
+      moduleAsSourceById.delete(link.id);
+      const current = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey);
+      if (!current) return;
+      current.delete(link.id);
+      if (current.size === 0) {
+        moduleAsSourceIdsBySource.delete(link.sourceModuleInstanceKey);
+      }
+    };
+  };
+  const registerDeclarativeLink = (link) => {
+    const readNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.readNodes) {
+      readNodeById.set(n.nodeId, n);
+    }
+    const dispatchNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.dispatchNodes) {
+      dispatchNodeById.set(n.nodeId, n);
+    }
+    const incomingByDispatch = /* @__PURE__ */ new Map();
+    for (const e of link.ir.edges) {
+      const to = e.to;
+      const isDispatch = dispatchNodeById.has(to);
+      if (!isDispatch) continue;
+      incomingByDispatch.set(to, (incomingByDispatch.get(to) ?? 0) + 1);
+      const count = incomingByDispatch.get(to) ?? 0;
+      if (count > 1) {
+        throw new Error(
+          `[DeclarativeLinkRuntime] Invalid DeclarativeLinkIR: dispatch node has multiple incoming edges (linkId=${link.linkId}, nodeId=${to}).`
+        );
+      }
+    }
+    const dispatchTargetsByReadNode = /* @__PURE__ */ new Map();
+    for (const e of link.ir.edges) {
+      const from = e.from;
+      const to = e.to;
+      if (!readNodeById.has(from)) continue;
+      if (!dispatchNodeById.has(to)) continue;
+      const list = dispatchTargetsByReadNode.get(from) ?? [];
+      list.push(to);
+      dispatchTargetsByReadNode.set(from, list);
+    }
+    const stored = {
+      ...link,
+      readNodeById,
+      dispatchNodeById,
+      dispatchTargetsByReadNode,
+      readNodeState: /* @__PURE__ */ new Map()
+    };
+    declarativeById.set(link.linkId, stored);
+    for (const n of link.readNodes) {
+      const list = declarativeReadNodesBySource.get(n.moduleInstanceKey) ?? [];
+      list.push({ linkId: link.linkId, nodeId: n.nodeId });
+      declarativeReadNodesBySource.set(n.moduleInstanceKey, list);
+    }
+    return () => {
+      declarativeById.delete(link.linkId);
+      for (const n of link.readNodes) {
+        const list = declarativeReadNodesBySource.get(n.moduleInstanceKey);
+        if (!list) continue;
+        const next = list.filter((x) => !(x.linkId === link.linkId && x.nodeId === n.nodeId));
+        if (next.length === 0) {
+          declarativeReadNodesBySource.delete(n.moduleInstanceKey);
+        } else {
+          declarativeReadNodesBySource.set(n.moduleInstanceKey, next);
+        }
+      }
+    };
+  };
+  const applyForSources = (args) => import_effect7.Effect.gen(function* () {
+    let scheduled = false;
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const ids = moduleAsSourceIdsBySource.get(sourceKey);
+      if (!ids || ids.size === 0) continue;
+      const commit2 = args.acceptedModules.get(sourceKey);
+      if (!commit2) continue;
+      for (const id of ids) {
+        const link = moduleAsSourceById.get(id);
+        if (!link) continue;
+        let selected;
+        try {
+          selected = link.readQuery.select(commit2.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 commit2 = args.acceptedModules.get(sourceKey);
+      if (!commit2) 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(commit2.state);
+        } catch {
+          continue;
+        }
+        const state = link.readNodeState.get(ref.nodeId) ?? { hasValue: false, lastValue: void 0 };
+        const changed = !state.hasValue || !Object.is(state.lastValue, value);
+        if (!changed) continue;
+        state.hasValue = true;
+        state.lastValue = value;
+        link.readNodeState.set(ref.nodeId, state);
+        const targets = link.dispatchTargetsByReadNode.get(ref.nodeId) ?? [];
+        for (const dispatchNodeId of targets) {
+          const node = link.dispatchNodeById.get(dispatchNodeId);
+          if (!node) continue;
+          scheduled = true;
+          yield* node.dispatch(value);
+        }
+      }
+    }
+    return { scheduled };
+  });
+  return {
+    registerModuleAsSourceLink,
+    registerDeclarativeLink,
+    applyForSources
+  };
+};
+
+// src/internal/runtime/core/env.ts
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var StateTransactionConfigTag = StateTransactionConfigTagImpl;
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl;
+var ReplayModeConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var StateTransactionOverridesTag = StateTransactionOverridesTagImpl;
+var ConcurrencyPolicyTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl;
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+var ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl;
+var RuntimeStoreTag = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeStore")() {
+};
+var runtimeStoreLayer = import_effect8.Layer.scoped(
+  RuntimeStoreTag,
+  import_effect8.Effect.acquireRelease(
+    import_effect8.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect8.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect8.Context.Tag("@logixjs/core/HostScheduler")() {
+};
+var hostSchedulerLayer = import_effect8.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect8.Context.Tag("@logixjs/core/DeclarativeLinkRuntime")() {
+};
+var declarativeLinkRuntimeLayer = import_effect8.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect8.Context.Tag("@logixjs/core/TickScheduler")() {
+};
+var tickSchedulerLayer = (config) => import_effect8.Layer.effect(
+  TickSchedulerTag,
+  import_effect8.Effect.gen(function* () {
+    const store = yield* RuntimeStoreTag;
+    const declarativeLinkRuntime = yield* DeclarativeLinkRuntimeTag;
+    const hostScheduler = yield* HostSchedulerTag;
+    return makeTickScheduler({ runtimeStore: store, declarativeLinkRuntime, hostScheduler, config });
+  })
+);
+
+// src/internal/runtime/core/RootContext.ts
+var import_effect9 = require("effect");
+var RootContextTagImpl = class extends import_effect9.Context.Tag("@logixjs/core/RootContext")() {
+};
+var RootContextTag = RootContextTagImpl;
+
+// src/internal/runtime/core/process/ProcessRuntime.make.ts
+var import_effect11 = require("effect");
+
 // src/internal/runtime/core/runtimeInternalsAccessor.ts
 var RUNTIME_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeInternals");
 var BOUND_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/boundInternals");
@@ -1511,7 +2768,7 @@ var processInstanceIdFromIdentity = (identity) => {
 };
 
 // src/internal/runtime/core/process/concurrency.ts
-var import_effect7 = require("effect");
+var import_effect10 = require("effect");
 var DEFAULT_SERIAL_QUEUE_GUARD_LIMIT = 4096;
 var DEFAULT_PARALLEL_LIMIT = 16;
 var resolveQueueLimit = (maxQueue, options) => {
@@ -1522,37 +2779,37 @@ var resolveQueueLimit = (maxQueue, options) => {
     guard: configured === "unbounded" ? defaultGuard : configured
   };
 };
-var runProcessTriggerStream = (args) => import_effect7.Effect.gen(function* () {
+var runProcessTriggerStream = (args) => import_effect10.Effect.gen(function* () {
   const policy = args.policy;
   const defaultQueueGuard = args.defaultQueueGuard ?? DEFAULT_SERIAL_QUEUE_GUARD_LIMIT;
   if (policy.mode === "latest") {
-    const stateRef = yield* import_effect7.Ref.make({ fiber: void 0, runningId: 0, nextId: 0 });
-    const onTrigger2 = (trigger0) => import_effect7.Effect.gen(function* () {
+    const stateRef = yield* import_effect10.Ref.make({ fiber: void 0, runningId: 0, nextId: 0 });
+    const onTrigger2 = (trigger0) => import_effect10.Effect.gen(function* () {
       const trigger = args.assignTriggerSeq(trigger0);
-      const [prevFiber, prevRunningId, runId] = yield* import_effect7.Ref.modify(stateRef, (s) => {
+      const [prevFiber, prevRunningId, runId] = yield* import_effect10.Ref.modify(stateRef, (s) => {
         const nextId = s.nextId + 1;
         return [[s.fiber, s.runningId, nextId], { ...s, nextId, runningId: nextId }];
       });
       if (prevFiber && prevRunningId !== 0) {
-        const done = yield* import_effect7.Fiber.poll(prevFiber);
-        if (import_effect7.Option.isNone(done)) {
-          yield* import_effect7.Fiber.interruptFork(prevFiber);
+        const done = yield* import_effect10.Fiber.poll(prevFiber);
+        if (import_effect10.Option.isNone(done)) {
+          yield* import_effect10.Fiber.interruptFork(prevFiber);
         }
       }
-      const fiber = yield* import_effect7.Effect.forkScoped(
-        args.run(trigger).pipe(import_effect7.Effect.ensuring(import_effect7.Ref.update(stateRef, (s) => s.runningId === runId ? { ...s, runningId: 0 } : s)))
+      const fiber = yield* import_effect10.Effect.forkScoped(
+        args.run(trigger).pipe(import_effect10.Effect.ensuring(import_effect10.Ref.update(stateRef, (s) => s.runningId === runId ? { ...s, runningId: 0 } : s)))
       );
-      yield* import_effect7.Ref.update(stateRef, (s) => ({ ...s, fiber }));
+      yield* import_effect10.Ref.update(stateRef, (s) => ({ ...s, fiber }));
     });
-    return yield* import_effect7.Stream.runForEach(args.stream, onTrigger2);
+    return yield* import_effect10.Stream.runForEach(args.stream, onTrigger2);
   }
-  const busyRef = yield* import_effect7.Ref.make(false);
-  const serialStateRef = yield* import_effect7.Ref.make({
+  const busyRef = yield* import_effect10.Ref.make(false);
+  const serialStateRef = yield* import_effect10.Ref.make({
     running: false,
     queue: [],
     peak: 0
   });
-  const parallelStateRef = yield* import_effect7.Ref.make({
+  const parallelStateRef = yield* import_effect10.Ref.make({
     active: 0,
     queue: [],
     peak: 0
@@ -1560,57 +2817,57 @@ var runProcessTriggerStream = (args) => import_effect7.Effect.gen(function* () {
   const serialQueueLimit = resolveQueueLimit(policy.maxQueue, { defaultGuard: defaultQueueGuard });
   const parallelQueueLimit = resolveQueueLimit(void 0, { defaultGuard: defaultQueueGuard });
   const parallelLimit = typeof policy.maxParallel === "number" && Number.isFinite(policy.maxParallel) && policy.maxParallel >= 1 ? Math.floor(policy.maxParallel) : args.defaultParallelLimit ?? DEFAULT_PARALLEL_LIMIT;
-  const drainSerial = () => import_effect7.Effect.suspend(
-    () => import_effect7.Ref.modify(serialStateRef, (state) => {
+  const drainSerial = () => import_effect10.Effect.suspend(
+    () => import_effect10.Ref.modify(serialStateRef, (state) => {
       if (state.running || state.queue.length === 0) {
-        return [import_effect7.Option.none(), state];
+        return [import_effect10.Option.none(), state];
       }
       const [next, ...rest] = state.queue;
-      return [import_effect7.Option.some(next), { ...state, running: true, queue: rest }];
+      return [import_effect10.Option.some(next), { ...state, running: true, queue: rest }];
     }).pipe(
-      import_effect7.Effect.flatMap(
-        (next) => import_effect7.Option.match(next, {
-          onNone: () => import_effect7.Effect.void,
-          onSome: (trigger) => import_effect7.Effect.forkScoped(
+      import_effect10.Effect.flatMap(
+        (next) => import_effect10.Option.match(next, {
+          onNone: () => import_effect10.Effect.void,
+          onSome: (trigger) => import_effect10.Effect.forkScoped(
             args.run(trigger).pipe(
-              import_effect7.Effect.ensuring(import_effect7.Ref.update(serialStateRef, (s) => ({ ...s, running: false }))),
-              import_effect7.Effect.zipRight(drainSerial())
+              import_effect10.Effect.ensuring(import_effect10.Ref.update(serialStateRef, (s) => ({ ...s, running: false }))),
+              import_effect10.Effect.zipRight(drainSerial())
             )
-          ).pipe(import_effect7.Effect.asVoid)
+          ).pipe(import_effect10.Effect.asVoid)
         })
       )
     )
   );
-  const drainParallel = () => import_effect7.Effect.suspend(
-    () => import_effect7.Ref.modify(parallelStateRef, (state) => {
+  const drainParallel = () => import_effect10.Effect.suspend(
+    () => import_effect10.Ref.modify(parallelStateRef, (state) => {
       if (state.active >= parallelLimit || state.queue.length === 0) {
-        return [import_effect7.Option.none(), state];
+        return [import_effect10.Option.none(), state];
       }
       const [next, ...rest] = state.queue;
-      return [import_effect7.Option.some(next), { ...state, active: state.active + 1, queue: rest }];
+      return [import_effect10.Option.some(next), { ...state, active: state.active + 1, queue: rest }];
     }).pipe(
-      import_effect7.Effect.flatMap(
-        (next) => import_effect7.Option.match(next, {
-          onNone: () => import_effect7.Effect.void,
-          onSome: (trigger) => import_effect7.Effect.forkScoped(
+      import_effect10.Effect.flatMap(
+        (next) => import_effect10.Option.match(next, {
+          onNone: () => import_effect10.Effect.void,
+          onSome: (trigger) => import_effect10.Effect.forkScoped(
             args.run(trigger).pipe(
-              import_effect7.Effect.ensuring(
-                import_effect7.Ref.update(parallelStateRef, (s) => ({
+              import_effect10.Effect.ensuring(
+                import_effect10.Ref.update(parallelStateRef, (s) => ({
                   ...s,
                   active: Math.max(0, s.active - 1)
                 }))
               ),
-              import_effect7.Effect.zipRight(drainParallel())
+              import_effect10.Effect.zipRight(drainParallel())
             )
-          ).pipe(import_effect7.Effect.asVoid, import_effect7.Effect.zipRight(drainParallel()))
+          ).pipe(import_effect10.Effect.asVoid, import_effect10.Effect.zipRight(drainParallel()))
         })
       )
     )
   );
-  const onTrigger = (trigger0) => import_effect7.Effect.gen(function* () {
+  const onTrigger = (trigger0) => import_effect10.Effect.gen(function* () {
     const trigger = args.assignTriggerSeq(trigger0);
     if (policy.mode === "drop") {
-      const acquired = yield* import_effect7.Ref.modify(
+      const acquired = yield* import_effect10.Ref.modify(
         busyRef,
         (busy) => busy ? [false, busy] : [true, true]
       );
@@ -1618,16 +2875,16 @@ var runProcessTriggerStream = (args) => import_effect7.Effect.gen(function* () {
         yield* args.onDrop(trigger);
         return;
       }
-      yield* import_effect7.Effect.forkScoped(args.run(trigger).pipe(import_effect7.Effect.ensuring(import_effect7.Ref.set(busyRef, false))));
+      yield* import_effect10.Effect.forkScoped(args.run(trigger).pipe(import_effect10.Effect.ensuring(import_effect10.Ref.set(busyRef, false))));
       return;
     }
     if (policy.mode === "parallel") {
-      const nextSize2 = yield* import_effect7.Ref.modify(parallelStateRef, (state) => {
+      const nextSize2 = yield* import_effect10.Ref.modify(parallelStateRef, (state) => {
         const queue = [...state.queue, trigger];
         return [queue.length, { ...state, queue, peak: Math.max(state.peak, queue.length) }];
       });
       if (nextSize2 > parallelQueueLimit.guard) {
-        const state = yield* import_effect7.Ref.get(parallelStateRef);
+        const state = yield* import_effect10.Ref.get(parallelStateRef);
         yield* args.onQueueOverflow({
           mode: "parallel",
           currentLength: nextSize2,
@@ -1640,12 +2897,12 @@ var runProcessTriggerStream = (args) => import_effect7.Effect.gen(function* () {
       yield* drainParallel();
       return;
     }
-    const nextSize = yield* import_effect7.Ref.modify(serialStateRef, (state) => {
+    const nextSize = yield* import_effect10.Ref.modify(serialStateRef, (state) => {
       const queue = [...state.queue, trigger];
       return [queue.length, { ...state, queue, peak: Math.max(state.peak, queue.length) }];
     });
     if (nextSize > serialQueueLimit.guard) {
-      const state = yield* import_effect7.Ref.get(serialStateRef);
+      const state = yield* import_effect10.Ref.get(serialStateRef);
       yield* args.onQueueOverflow({
         mode: "serial",
         currentLength: nextSize,
@@ -1657,7 +2914,7 @@ var runProcessTriggerStream = (args) => import_effect7.Effect.gen(function* () {
     }
     yield* drainSerial();
   });
-  return yield* import_effect7.Stream.runForEach(args.stream, onTrigger);
+  return yield* import_effect10.Stream.runForEach(args.stream, onTrigger);
 });
 
 // src/internal/runtime/core/process/events.ts
@@ -2032,11 +3289,11 @@ var onFailure = (policy, state, nowMs3) => {
   };
 };
 
-// src/internal/runtime/core/process/ProcessRuntime.ts
-var ProcessRuntimeTag = class extends import_effect8.Context.Tag("@logixjs/core/ProcessRuntime")() {
+// src/internal/runtime/core/process/ProcessRuntime.make.ts
+var ProcessRuntimeTag = class extends import_effect11.Context.Tag("@logixjs/core/ProcessRuntime")() {
 };
-var currentProcessTrigger = import_effect8.FiberRef.unsafeMake(void 0);
-var currentProcessEventBudget = import_effect8.FiberRef.unsafeMake(
+var currentProcessTrigger = import_effect11.FiberRef.unsafeMake(void 0);
+var currentProcessEventBudget = import_effect11.FiberRef.unsafeMake(
   void 0
 );
 var RUNTIME_BOOT_EVENT = "runtime:boot";
@@ -2095,13 +3352,13 @@ var actionIdFromUnknown = (action) => {
   if (typeof anyAction.type === "string" && anyAction.type.length > 0) return anyAction.type;
   return void 0;
 };
-var make = (options) => import_effect8.Effect.gen(function* () {
-  const runtimeScope = yield* import_effect8.Effect.scope;
+var make = (options) => import_effect11.Effect.gen(function* () {
+  const runtimeScope = yield* import_effect11.Effect.scope;
   const maxEventHistory = typeof options?.maxEventHistory === "number" && Number.isFinite(options.maxEventHistory) && options.maxEventHistory >= 0 ? Math.floor(options.maxEventHistory) : 500;
   const installations = /* @__PURE__ */ new Map();
   const instances2 = /* @__PURE__ */ new Map();
   const eventsBuffer = [];
-  const eventsHub = yield* import_effect8.PubSub.sliding(Math.max(1, Math.min(2048, maxEventHistory)));
+  const eventsHub = yield* import_effect11.PubSub.sliding(Math.max(1, Math.min(2048, maxEventHistory)));
   const trimEvents = () => {
     if (maxEventHistory <= 0) {
       eventsBuffer.length = 0;
@@ -2111,8 +3368,8 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     const excess = eventsBuffer.length - maxEventHistory;
     eventsBuffer.splice(0, excess);
   };
-  const recordDebugEvent = (event) => import_effect8.Effect.gen(function* () {
-    const diagnosticsLevel2 = yield* import_effect8.FiberRef.get(currentDiagnosticsLevel);
+  const recordDebugEvent = (event) => import_effect11.Effect.gen(function* () {
+    const diagnosticsLevel2 = yield* import_effect11.FiberRef.get(currentDiagnosticsLevel);
     if (diagnosticsLevel2 === "off") {
       return;
     }
@@ -2135,16 +3392,16 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       txnId
     });
   });
-  const publishEvent = (event) => import_effect8.Effect.gen(function* () {
+  const publishEvent = (event) => import_effect11.Effect.gen(function* () {
     eventsBuffer.push(event);
     trimEvents();
-    yield* import_effect8.PubSub.publish(eventsHub, event);
+    yield* import_effect11.PubSub.publish(eventsHub, event);
     yield* recordDebugEvent(event);
   });
-  const emit = (event) => import_effect8.Effect.gen(function* () {
-    const budgetRef = yield* import_effect8.FiberRef.get(currentProcessEventBudget);
+  const emit = (event) => import_effect11.Effect.gen(function* () {
+    const budgetRef = yield* import_effect11.FiberRef.get(currentProcessEventBudget);
     if (budgetRef) {
-      const decision = yield* import_effect8.Ref.modify(budgetRef, (state) => {
+      const decision = yield* import_effect11.Ref.modify(budgetRef, (state) => {
         const [nextDecision, nextState] = applyProcessRunEventBudget(state, event);
         return [nextDecision, nextState];
       });
@@ -2158,7 +3415,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
   });
   const emitErrorDiagnostic = (scope, processId, code, message, hint) => {
     if (!isDevEnv()) {
-      return import_effect8.Effect.void;
+      return import_effect11.Effect.void;
     }
     const moduleId = scope.type === "moduleInstance" ? scope.moduleId : void 0;
     const instanceId = scope.type === "moduleInstance" ? scope.instanceId : void 0;
@@ -2187,15 +3444,15 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     const missing = [];
     for (const dep of requires) {
       if (typeof dep !== "string" || dep.length === 0) continue;
-      const tag = import_effect8.Context.Tag(`@logixjs/Module/${dep}`)();
-      const found = import_effect8.Context.getOption(installation.env, tag);
-      if (import_effect8.Option.isNone(found)) {
+      const tag = import_effect11.Context.Tag(`@logixjs/Module/${dep}`)();
+      const found = import_effect11.Context.getOption(installation.env, tag);
+      if (import_effect11.Option.isNone(found)) {
         missing.push(dep);
       }
     }
     return missing;
   };
-  const stopInstance = (instance, reason) => import_effect8.Effect.gen(function* () {
+  const stopInstance = (instance, reason) => import_effect11.Effect.gen(function* () {
     if (instance.status.status === "stopped" || instance.status.status === "failed" || instance.status.status === "stopping") {
       return;
     }
@@ -2206,9 +3463,9 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       stoppedReason: reason
     };
     if (fiber) {
-      yield* import_effect8.Fiber.interrupt(fiber);
+      yield* import_effect11.Fiber.interrupt(fiber);
     }
-    yield* import_effect8.Queue.shutdown(instance.platformTriggersQueue);
+    yield* import_effect11.Queue.shutdown(instance.platformTriggersQueue);
     instance.status = {
       ...instance.status,
       status: "stopped",
@@ -2229,7 +3486,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       yield* startInstallation(instance.installationKey);
     }
   });
-  const startInstallation = (installationKey) => import_effect8.Effect.gen(function* () {
+  const startInstallation = (installationKey) => import_effect11.Effect.gen(function* () {
     const installation = installations.get(installationKey);
     if (!installation) return;
     installation.pendingStart = void 0;
@@ -2248,7 +3505,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       runSeq
     };
     const processInstanceId = processInstanceIdFromIdentity(identity);
-    const platformTriggersQueue = yield* import_effect8.Queue.sliding(64);
+    const platformTriggersQueue = yield* import_effect11.Queue.sliding(64);
     const instanceState = {
       installationKey,
       processInstanceId,
@@ -2267,15 +3524,15 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     instances2.set(processInstanceId, instanceState);
     installation.currentInstanceId = processInstanceId;
     if (installation.forkScope !== runtimeScope) {
-      yield* import_effect8.Scope.addFinalizer(
+      yield* import_effect11.Scope.addFinalizer(
         installation.forkScope,
-        import_effect8.Effect.suspend(() => {
+        import_effect11.Effect.suspend(() => {
           const status = instanceState.status.status;
           if (status === "stopped" || status === "failed" || status === "stopping") {
-            return import_effect8.Effect.void;
+            return import_effect11.Effect.void;
           }
           return stopInstance(instanceState, "scopeDisposed");
-        }).pipe(import_effect8.Effect.catchAllCause(() => import_effect8.Effect.void))
+        }).pipe(import_effect11.Effect.catchAllCause(() => import_effect11.Effect.void))
       );
     }
     yield* emit({
@@ -2338,12 +3595,12 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       let nextEnv = baseEnv;
       for (const moduleId of ids) {
         if (typeof moduleId !== "string" || moduleId.length === 0) continue;
-        const tag = import_effect8.Context.Tag(`@logixjs/Module/${moduleId}`)();
-        const found = import_effect8.Context.getOption(baseEnv, tag);
-        if (import_effect8.Option.isNone(found)) continue;
+        const tag = import_effect11.Context.Tag(`@logixjs/Module/${moduleId}`)();
+        const found = import_effect11.Context.getOption(baseEnv, tag);
+        if (import_effect11.Option.isNone(found)) continue;
         const runtime = found.value;
-        const recordDispatch = (action) => import_effect8.Effect.gen(function* () {
-          const trigger = yield* import_effect8.FiberRef.get(currentProcessTrigger);
+        const recordDispatch = (action) => import_effect11.Effect.gen(function* () {
+          const trigger = yield* import_effect11.FiberRef.get(currentProcessTrigger);
           if (!trigger) return;
           const actionId = actionIdFromUnknown(action) ?? "unknown";
           const dispatchModuleId = typeof runtime.moduleId === "string" ? runtime.moduleId : moduleId;
@@ -2365,27 +3622,27 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         });
         const wrapped = {
           ...runtime,
-          dispatch: (action) => runtime.dispatch(action).pipe(import_effect8.Effect.tap(() => recordDispatch(action))),
-          dispatchLowPriority: (action) => runtime.dispatchLowPriority(action).pipe(import_effect8.Effect.tap(() => recordDispatch(action))),
-          dispatchBatch: (actions) => runtime.dispatchBatch(actions).pipe(import_effect8.Effect.tap(() => import_effect8.Effect.forEach(actions, recordDispatch, { discard: true })))
+          dispatch: (action) => runtime.dispatch(action).pipe(import_effect11.Effect.tap(() => recordDispatch(action))),
+          dispatchLowPriority: (action) => runtime.dispatchLowPriority(action).pipe(import_effect11.Effect.tap(() => recordDispatch(action))),
+          dispatchBatch: (actions) => runtime.dispatchBatch(actions).pipe(import_effect11.Effect.tap(() => import_effect11.Effect.forEach(actions, recordDispatch, { discard: true })))
         };
-        nextEnv = import_effect8.Context.add(tag, wrapped)(nextEnv);
+        nextEnv = import_effect11.Context.add(tag, wrapped)(nextEnv);
       }
       return nextEnv;
     };
     const wrappedEnv = makeWrappedEnv();
-    const providedProcess = import_effect8.Effect.provide(installation.process, wrappedEnv);
-    const makeTriggerStream = (spec) => import_effect8.Effect.gen(function* () {
+    const providedProcess = import_effect11.Effect.provide(installation.process, wrappedEnv);
+    const makeTriggerStream = (spec) => import_effect11.Effect.gen(function* () {
       if (spec.kind === "timer") {
-        const interval = import_effect8.Duration.decodeUnknown(spec.timerId);
-        if (import_effect8.Option.isNone(interval)) {
+        const interval = import_effect11.Duration.decodeUnknown(spec.timerId);
+        if (import_effect11.Option.isNone(interval)) {
           const err = new Error(`[ProcessRuntime] invalid timerId (expected DurationInput): ${spec.timerId}`);
           err.code = "process::invalid_timer_id";
           err.hint = "timerId must be a valid DurationInput string, e.g. '10 millis', '1 seconds', '5 minutes'.";
-          return yield* import_effect8.Effect.fail(err);
+          return yield* import_effect11.Effect.fail(err);
         }
-        return import_effect8.Stream.tick(interval.value).pipe(
-          import_effect8.Stream.map(
+        return import_effect11.Stream.tick(interval.value).pipe(
+          import_effect11.Stream.map(
             () => ({
               kind: "timer",
               name: spec.name,
@@ -2395,10 +3652,10 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         );
       }
       if (spec.kind === "moduleAction") {
-        const tag2 = import_effect8.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
-        const found2 = import_effect8.Context.getOption(baseEnv, tag2);
-        if (import_effect8.Option.isNone(found2)) {
-          return yield* import_effect8.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
+        const tag2 = import_effect11.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
+        const found2 = import_effect11.Context.getOption(baseEnv, tag2);
+        if (import_effect11.Option.isNone(found2)) {
+          return yield* import_effect11.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
         }
         const runtime2 = found2.value;
         if (!shouldRecordChainEvents) {
@@ -2407,11 +3664,11 @@ var make = (options) => import_effect8.Effect.gen(function* () {
             const err = new Error("ModuleRuntime does not provide actions$ (required for moduleAction trigger).");
             err.code = "process::missing_action_stream";
             err.hint = `moduleId=${spec.moduleId}`;
-            return yield* import_effect8.Effect.fail(err);
+            return yield* import_effect11.Effect.fail(err);
           }
           return stream2.pipe(
-            import_effect8.Stream.filter((action) => actionIdFromUnknown(action) === spec.actionId),
-            import_effect8.Stream.map(
+            import_effect11.Stream.filter((action) => actionIdFromUnknown(action) === spec.actionId),
+            import_effect11.Stream.map(
               () => ({
                 kind: "moduleAction",
                 name: spec.name,
@@ -2430,11 +3687,11 @@ var make = (options) => import_effect8.Effect.gen(function* () {
           );
           err.code = "process::missing_action_meta_stream";
           err.hint = `moduleId=${spec.moduleId}`;
-          return yield* import_effect8.Effect.fail(err);
+          return yield* import_effect11.Effect.fail(err);
         }
         return stream.pipe(
-          import_effect8.Stream.filter((evt) => actionIdFromUnknown(evt.value) === spec.actionId),
-          import_effect8.Stream.map((evt) => {
+          import_effect11.Stream.filter((evt) => actionIdFromUnknown(evt.value) === spec.actionId),
+          import_effect11.Stream.map((evt) => {
             const txnSeq = evt?.meta?.txnSeq;
             return {
               kind: "moduleAction",
@@ -2447,21 +3704,21 @@ var make = (options) => import_effect8.Effect.gen(function* () {
           })
         );
       }
-      const tag = import_effect8.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
-      const found = import_effect8.Context.getOption(baseEnv, tag);
-      if (import_effect8.Option.isNone(found)) {
-        return yield* import_effect8.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
+      const tag = import_effect11.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
+      const found = import_effect11.Context.getOption(baseEnv, tag);
+      if (import_effect11.Option.isNone(found)) {
+        return yield* import_effect11.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
       }
       const runtime = found.value;
       const schemaAst = resolveRuntimeStateSchemaAst(runtime);
       const selectorResult = makeSchemaSelector(spec.path, schemaAst);
       if (!selectorResult.ok) {
-        return yield* import_effect8.Effect.fail(withModuleHint(selectorResult.error, spec.moduleId));
+        return yield* import_effect11.Effect.fail(withModuleHint(selectorResult.error, spec.moduleId));
       }
       const selectorBase = selectorResult.selector;
-      const prevRef = yield* import_effect8.Ref.make(import_effect8.Option.none());
+      const prevRef = yield* import_effect11.Ref.make(import_effect11.Option.none());
       const enableSelectorDiagnostics = shouldRecordChainEvents;
-      const selectorDiagnosticsRef = enableSelectorDiagnostics ? yield* import_effect8.Ref.make({
+      const selectorDiagnosticsRef = enableSelectorDiagnostics ? yield* import_effect11.Ref.make({
         windowStartedMs: Date.now(),
         triggersInWindow: 0,
         lastWarningAtMs: 0
@@ -2500,11 +3757,11 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       } : selectorBase;
       const maybeWarnSelector = (trigger) => {
         if (!selectorDiagnosticsRef) {
-          return import_effect8.Effect.void;
+          return import_effect11.Effect.void;
         }
-        return import_effect8.Effect.gen(function* () {
+        return import_effect11.Effect.gen(function* () {
           const now = Date.now();
-          const decision = yield* import_effect8.Ref.modify(selectorDiagnosticsRef, (s) => {
+          const decision = yield* import_effect11.Ref.modify(selectorDiagnosticsRef, (s) => {
             const windowExpired = now - s.windowStartedMs >= triggerWindowMs;
             const windowStartedMs = windowExpired ? now : s.windowStartedMs;
             const triggersInWindow = windowExpired ? 1 : s.triggersInWindow + 1;
@@ -2572,18 +3829,18 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         });
       };
       const baseStream = runtime.changesWithMeta(selector).pipe(
-        import_effect8.Stream.mapEffect(
-          (evt) => import_effect8.Ref.get(prevRef).pipe(
-            import_effect8.Effect.flatMap((prev) => {
-              if (import_effect8.Option.isSome(prev) && Object.is(prev.value, evt.value)) {
-                return import_effect8.Effect.succeed(import_effect8.Option.none());
+        import_effect11.Stream.mapEffect(
+          (evt) => import_effect11.Ref.get(prevRef).pipe(
+            import_effect11.Effect.flatMap((prev) => {
+              if (import_effect11.Option.isSome(prev) && Object.is(prev.value, evt.value)) {
+                return import_effect11.Effect.succeed(import_effect11.Option.none());
               }
-              return import_effect8.Ref.set(prevRef, import_effect8.Option.some(evt.value)).pipe(import_effect8.Effect.as(import_effect8.Option.some(evt)));
+              return import_effect11.Ref.set(prevRef, import_effect11.Option.some(evt.value)).pipe(import_effect11.Effect.as(import_effect11.Option.some(evt)));
             })
           )
         ),
-        import_effect8.Stream.filterMap((opt) => opt),
-        import_effect8.Stream.map((evt) => {
+        import_effect11.Stream.filterMap((opt) => opt),
+        import_effect11.Stream.map((evt) => {
           const txnSeq = evt?.meta?.txnSeq;
           return {
             kind: "moduleStateChange",
@@ -2595,20 +3852,20 @@ var make = (options) => import_effect8.Effect.gen(function* () {
           };
         })
       );
-      return enableSelectorDiagnostics ? baseStream.pipe(import_effect8.Stream.tap(maybeWarnSelector)) : baseStream;
+      return enableSelectorDiagnostics ? baseStream.pipe(import_effect11.Stream.tap(maybeWarnSelector)) : baseStream;
     });
-    const makeRun = (trigger, fatal) => import_effect8.Effect.locally(
+    const makeRun = (trigger, fatal) => import_effect11.Effect.locally(
       currentProcessTrigger,
       trigger
     )(
       providedProcess.pipe(
-        import_effect8.Effect.catchAllCause((cause) => {
-          if (import_effect8.Cause.isInterruptedOnly(cause)) {
-            return import_effect8.Effect.void;
+        import_effect11.Effect.catchAllCause((cause) => {
+          if (import_effect11.Cause.isInterruptedOnly(cause)) {
+            return import_effect11.Effect.void;
           }
-          return import_effect8.Deferred.succeed(fatal, cause).pipe(
-            import_effect8.Effect.asVoid,
-            import_effect8.Effect.catchAll(() => import_effect8.Effect.void)
+          return import_effect11.Deferred.succeed(fatal, cause).pipe(
+            import_effect11.Effect.asVoid,
+            import_effect11.Effect.catchAll(() => import_effect11.Effect.void)
           );
         })
       )
@@ -2617,12 +3874,12 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       if (!shouldRecordChainEvents) {
         return makeRun(trigger, fatal);
       }
-      return import_effect8.Effect.gen(function* () {
-        const budgetRef = yield* import_effect8.Ref.make(makeProcessRunEventBudgetState());
-        return yield* import_effect8.Effect.locally(
+      return import_effect11.Effect.gen(function* () {
+        const budgetRef = yield* import_effect11.Ref.make(makeProcessRunEventBudgetState());
+        return yield* import_effect11.Effect.locally(
           currentProcessEventBudget,
           budgetRef
-        )(emitTriggerEvent(trigger, "info").pipe(import_effect8.Effect.zipRight(makeRun(trigger, fatal))));
+        )(emitTriggerEvent(trigger, "info").pipe(import_effect11.Effect.zipRight(makeRun(trigger, fatal))));
       });
     };
     const assignTriggerSeq = (trigger) => {
@@ -2636,7 +3893,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     };
     const emitTriggerEvent = (trigger, severity) => {
       if (!shouldRecordChainEvents) {
-        return import_effect8.Effect.void;
+        return import_effect11.Effect.void;
       }
       const evt = {
         type: "process:trigger",
@@ -2655,16 +3912,16 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     const bootTriggerSpec = installation.definition.triggers.find(
       (t) => t.kind === "platformEvent" && t.platformEvent === RUNTIME_BOOT_EVENT
     );
-    const instanceProgram = import_effect8.Effect.gen(function* () {
-      const fatal = yield* import_effect8.Deferred.make();
-      const platformEventStream = import_effect8.Stream.fromQueue(
+    const instanceProgram = import_effect11.Effect.gen(function* () {
+      const fatal = yield* import_effect11.Deferred.make();
+      const platformEventStream = import_effect11.Stream.fromQueue(
         instanceState.platformTriggersQueue
       );
       const nonPlatformTriggers = installation.definition.triggers.filter(
         (t) => t.kind !== "platformEvent"
       );
-      const streams = yield* import_effect8.Effect.forEach(nonPlatformTriggers, makeTriggerStream);
-      const triggerStream = import_effect8.Stream.mergeAll([platformEventStream, ...streams], {
+      const streams = yield* import_effect11.Effect.forEach(nonPlatformTriggers, makeTriggerStream);
+      const triggerStream = import_effect11.Stream.mergeAll([platformEventStream, ...streams], {
         concurrency: "unbounded"
       });
       const reportQueueOverflow = (info) => {
@@ -2679,12 +3936,12 @@ var make = (options) => import_effect8.Effect.gen(function* () {
           "fix:",
           "- Configure concurrency.maxQueue (serial) to a finite value, or switch to mode=latest/drop to avoid unbounded backlog."
         ].join("\n");
-        return import_effect8.Deferred.succeed(fatal, import_effect8.Cause.fail(err)).pipe(
-          import_effect8.Effect.asVoid,
-          import_effect8.Effect.catchAll(() => import_effect8.Effect.void)
+        return import_effect11.Deferred.succeed(fatal, import_effect11.Cause.fail(err)).pipe(
+          import_effect11.Effect.asVoid,
+          import_effect11.Effect.catchAll(() => import_effect11.Effect.void)
         );
       };
-      const runnerFiber = yield* import_effect8.Effect.forkScoped(
+      const runnerFiber = yield* import_effect11.Effect.forkScoped(
         runProcessTriggerStream({
           stream: triggerStream,
           policy,
@@ -2695,21 +3952,21 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         })
       );
       if (autoStart) {
-        yield* import_effect8.Queue.offer(instanceState.platformTriggersQueue, {
+        yield* import_effect11.Queue.offer(instanceState.platformTriggersQueue, {
           kind: "platformEvent",
           name: bootTriggerSpec?.name,
           platformEvent: RUNTIME_BOOT_EVENT
         });
       }
-      const cause = yield* import_effect8.Deferred.await(fatal);
-      yield* import_effect8.Fiber.interrupt(runnerFiber);
-      return yield* import_effect8.Effect.failCause(cause);
+      const cause = yield* import_effect11.Deferred.await(fatal);
+      yield* import_effect11.Fiber.interrupt(runnerFiber);
+      return yield* import_effect11.Effect.failCause(cause);
     });
-    const fiber = yield* import_effect8.Effect.forkIn(installation.forkScope)(
-      import_effect8.Effect.scoped(instanceProgram).pipe(
-        import_effect8.Effect.catchAllCause(
-          (cause) => import_effect8.Effect.gen(function* () {
-            if (import_effect8.Cause.isInterruptedOnly(cause)) {
+    const fiber = yield* import_effect11.Effect.forkIn(installation.forkScope)(
+      import_effect11.Effect.scoped(instanceProgram).pipe(
+        import_effect11.Effect.catchAllCause(
+          (cause) => import_effect11.Effect.gen(function* () {
+            if (import_effect11.Cause.isInterruptedOnly(cause)) {
               if (instanceState.status.status === "stopping") {
                 return;
               }
@@ -2719,7 +3976,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
                 stoppedReason: "scopeDisposed"
               };
               instanceState.fiber = void 0;
-              yield* import_effect8.Effect.uninterruptible(
+              yield* import_effect11.Effect.uninterruptible(
                 emit({
                   type: "process:stop",
                   identity,
@@ -2735,9 +3992,9 @@ var make = (options) => import_effect8.Effect.gen(function* () {
               }
               return;
             }
-            const primary = import_effect8.Option.getOrElse(
-              import_effect8.Cause.failureOption(cause),
-              () => import_effect8.Option.getOrElse(import_effect8.Cause.dieOption(cause), () => cause)
+            const primary = import_effect11.Option.getOrElse(
+              import_effect11.Cause.failureOption(cause),
+              () => import_effect11.Option.getOrElse(import_effect11.Cause.dieOption(cause), () => cause)
             );
             const summary = toSerializableErrorSummary(primary);
             const error = summary.errorSummary;
@@ -2789,16 +4046,16 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       ...instanceState.status,
       status: "running"
     };
-    yield* import_effect8.Effect.yieldNow();
+    yield* import_effect11.Effect.yieldNow();
   });
-  const install = (process, options2) => import_effect8.Effect.gen(function* () {
+  const install = (process, options2) => import_effect11.Effect.gen(function* () {
     const meta = getMeta(process);
     if (!meta) {
       return void 0;
     }
-    const env = yield* import_effect8.Effect.context();
-    const forkScopeOpt = yield* import_effect8.Effect.serviceOption(import_effect8.Scope.Scope);
-    const forkScope = import_effect8.Option.isSome(forkScopeOpt) ? forkScopeOpt.value : runtimeScope;
+    const env = yield* import_effect11.Effect.context();
+    const forkScopeOpt = yield* import_effect11.Effect.serviceOption(import_effect11.Scope.Scope);
+    const forkScope = import_effect11.Option.isSome(forkScopeOpt) ? forkScopeOpt.value : runtimeScope;
     const scopeKey = scopeKeyFromScope(options2.scope);
     const identity = {
       processId: meta.definition.processId,
@@ -2826,9 +4083,9 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         const mode = options2.mode ?? "switch";
         if (mode === "switch" && current && current.forkScope !== forkScope) {
           existing.pendingStart = { forkScope };
-          yield* import_effect8.Scope.addFinalizer(
+          yield* import_effect11.Scope.addFinalizer(
             forkScope,
-            import_effect8.Effect.sync(() => {
+            import_effect11.Effect.sync(() => {
               const installation2 = installations.get(installationKey);
               if (!installation2) return;
               if (installation2.pendingStart?.forkScope === forkScope) {
@@ -2849,9 +4106,9 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         const mode = options2.mode ?? "switch";
         if (mode === "switch") {
           existing.pendingStart = { forkScope };
-          yield* import_effect8.Scope.addFinalizer(
+          yield* import_effect11.Scope.addFinalizer(
             forkScope,
-            import_effect8.Effect.sync(() => {
+            import_effect11.Effect.sync(() => {
               const installation2 = installations.get(installationKey);
               if (!installation2) return;
               if (installation2.pendingStart?.forkScope === forkScope) {
@@ -2876,7 +4133,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         installedAt: existing.installedAt
       };
     }
-    const derived = import_effect8.Effect.suspend(() => process);
+    const derived = import_effect11.Effect.suspend(() => process);
     attachMeta(derived, {
       ...meta,
       installationScope: options2.scope
@@ -2905,7 +4162,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       installedAt: installation.installedAt
     };
   });
-  const listInstallations = (filter) => import_effect8.Effect.sync(() => {
+  const listInstallations = (filter) => import_effect11.Effect.sync(() => {
     const scopeType = filter?.scopeType;
     const scopeKey = filter?.scopeKey;
     const out = [];
@@ -2920,26 +4177,26 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     }
     return out;
   });
-  const getInstanceStatus = (processInstanceId) => import_effect8.Effect.sync(() => instances2.get(processInstanceId)?.status);
-  const controlInstance = (processInstanceId, request) => import_effect8.Effect.suspend(() => {
+  const getInstanceStatus = (processInstanceId) => import_effect11.Effect.sync(() => instances2.get(processInstanceId)?.status);
+  const controlInstance = (processInstanceId, request) => import_effect11.Effect.suspend(() => {
     const instance = instances2.get(processInstanceId);
     if (!instance) {
-      return import_effect8.Effect.void;
+      return import_effect11.Effect.void;
     }
     return shouldNoopDueToSyncTxn(instance.scope, "process_control_in_transaction").pipe(
-      import_effect8.Effect.flatMap((noop) => {
+      import_effect11.Effect.flatMap((noop) => {
         if (noop) {
-          return import_effect8.Effect.void;
+          return import_effect11.Effect.void;
         }
         if (request.action === "stop") {
           return stopInstance(instance, "manualStop");
         }
         if (request.action === "restart") {
           return stopInstance(instance, "manualStop").pipe(
-            import_effect8.Effect.flatMap(() => {
+            import_effect11.Effect.flatMap(() => {
               const installation = installations.get(instance.installationKey);
               if (!installation) {
-                return import_effect8.Effect.void;
+                return import_effect11.Effect.void;
               }
               installation.currentInstanceId = void 0;
               return startInstallation(instance.installationKey);
@@ -2948,20 +4205,20 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         }
         if (request.action === "start") {
           if (instance.status.status === "running" || instance.status.status === "starting") {
-            return import_effect8.Effect.void;
+            return import_effect11.Effect.void;
           }
           const installation = installations.get(instance.installationKey);
           if (!installation) {
-            return import_effect8.Effect.void;
+            return import_effect11.Effect.void;
           }
           installation.currentInstanceId = void 0;
           return startInstallation(instance.installationKey);
         }
-        return import_effect8.Effect.void;
+        return import_effect11.Effect.void;
       })
     );
   });
-  const deliverPlatformEvent = (event) => import_effect8.Effect.gen(function* () {
+  const deliverPlatformEvent = (event) => import_effect11.Effect.gen(function* () {
     const noop = yield* shouldNoopInSyncTransactionFiber({
       code: "process::invalid_usage",
       severity: "error",
@@ -2972,25 +4229,25 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     if (noop) return;
     const targets = Array.from(instances2.values());
     const eventName = event.eventName;
-    yield* import_effect8.Effect.forEach(
+    yield* import_effect11.Effect.forEach(
       targets,
-      (instance) => import_effect8.Effect.suspend(() => {
+      (instance) => import_effect11.Effect.suspend(() => {
         if (instance.status.status !== "starting" && instance.status.status !== "running") {
-          return import_effect8.Effect.void;
+          return import_effect11.Effect.void;
         }
         const installation = installations.get(instance.installationKey);
         if (!installation) {
-          return import_effect8.Effect.void;
+          return import_effect11.Effect.void;
         }
         const specs = installation.definition.triggers.filter(
           (t) => t.kind === "platformEvent" && t.platformEvent === eventName
         );
         if (specs.length === 0) {
-          return import_effect8.Effect.void;
+          return import_effect11.Effect.void;
         }
-        return import_effect8.Effect.forEach(
+        return import_effect11.Effect.forEach(
           specs,
-          (spec) => import_effect8.Queue.offer(instance.platformTriggersQueue, {
+          (spec) => import_effect11.Queue.offer(instance.platformTriggersQueue, {
             kind: "platformEvent",
             name: spec.name,
             platformEvent: spec.platformEvent
@@ -3001,10 +4258,10 @@ var make = (options) => import_effect8.Effect.gen(function* () {
       { discard: true }
     );
   });
-  const eventsStream = import_effect8.Stream.fromPubSub(eventsHub);
-  const getEventsSnapshot = () => import_effect8.Effect.sync(() => eventsBuffer.slice());
-  yield* import_effect8.Effect.addFinalizer(
-    () => import_effect8.Effect.gen(function* () {
+  const eventsStream = import_effect11.Stream.fromPubSub(eventsHub);
+  const getEventsSnapshot = () => import_effect11.Effect.sync(() => eventsBuffer.slice());
+  yield* import_effect11.Effect.addFinalizer(
+    () => import_effect11.Effect.gen(function* () {
       for (const installation of installations.values()) {
         installation.pendingStart = void 0;
       }
@@ -3014,10 +4271,10 @@ var make = (options) => import_effect8.Effect.gen(function* () {
         }
       }
     }).pipe(
-      import_effect8.Effect.catchAllCause(
-        (cause) => import_effect8.Effect.sync(() => {
+      import_effect11.Effect.catchAllCause(
+        (cause) => import_effect11.Effect.sync(() => {
           if (isDevEnv()) {
-            console.warn("[ProcessRuntime] finalizer failed", import_effect8.Cause.pretty(cause));
+            console.warn("[ProcessRuntime] finalizer failed", import_effect11.Cause.pretty(cause));
           }
         })
       )
@@ -3033,7 +4290,7 @@ var make = (options) => import_effect8.Effect.gen(function* () {
     getEventsSnapshot
   };
 });
-var layer = (options) => import_effect8.Layer.scoped(ProcessRuntimeTag, make(options));
+var layer = (options) => import_effect11.Layer.scoped(ProcessRuntimeTag, make(options));
 
 // src/internal/runtime/AppRuntime.ts
 var getTagKey = (tag) => {
@@ -3129,95 +4386,113 @@ Ensure all modules in the application Runtime have unique IDs.`
     seenIds.add(id);
   }
   validateTags(config.modules);
-  const stateTxnLayer = config.stateTransaction ? import_effect9.Layer.succeed(StateTransactionConfigTag, config.stateTransaction) : import_effect9.Layer.empty;
-  const concurrencyPolicyLayer = config.concurrencyPolicy ? import_effect9.Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) : import_effect9.Layer.empty;
-  const readQueryStrictGateLayer = config.readQueryStrictGate ? import_effect9.Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) : import_effect9.Layer.empty;
+  const stateTxnLayer = config.stateTransaction ? import_effect12.Layer.succeed(StateTransactionConfigTag, config.stateTransaction) : import_effect12.Layer.empty;
+  const concurrencyPolicyLayer = config.concurrencyPolicy ? import_effect12.Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) : import_effect12.Layer.empty;
+  const readQueryStrictGateLayer = config.readQueryStrictGate ? import_effect12.Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) : import_effect12.Layer.empty;
   const appModuleIds = config.modules.map((entry) => String(entry.module.id));
   const appId = appModuleIds.length === 1 ? appModuleIds[0] : appModuleIds.slice().sort().join("~");
-  const baseLayer = import_effect9.Layer.mergeAll(
-    config.layer,
+  const pinnedHostSchedulerLayer = config.hostScheduler !== void 0 ? import_effect12.Layer.succeed(HostSchedulerTag, config.hostScheduler) : void 0;
+  const tickServicesLayer = import_effect12.Layer.provideMerge(pinnedHostSchedulerLayer ?? hostSchedulerLayer)(
+    import_effect12.Layer.provideMerge(runtimeStoreLayer)(import_effect12.Layer.provideMerge(declarativeLinkRuntimeLayer)(tickSchedulerLayer()))
+  );
+  const appLayer = config.layer.pipe(import_effect12.Layer.provide(tickServicesLayer));
+  const baseLayer = import_effect12.Layer.mergeAll(
+    tickServicesLayer,
+    appLayer,
+    // If a HostScheduler override is requested, pin it as the final HostSchedulerTag value to avoid accidental divergence.
+    // (Build-time capture is handled above by injecting it into tickServicesLayer.)
+    pinnedHostSchedulerLayer ?? import_effect12.Layer.empty,
     stateTxnLayer,
     concurrencyPolicyLayer,
     readQueryStrictGateLayer,
     layer(),
-    import_effect9.Layer.effect(
+    import_effect12.Layer.effect(
       RootContextTag,
-      import_effect9.Effect.gen(function* () {
-        const ready = yield* import_effect9.Deferred.make();
+      import_effect12.Effect.gen(function* () {
+        const ready = yield* import_effect12.Deferred.make();
         return { context: void 0, ready, appId, appModuleIds };
       })
     )
   );
-  const moduleLayers = config.modules.map(
-    (entry) => (
-      // Ensure each module layer can see the app Env (baseLayer) to avoid missing root env during initialization.
-      import_effect9.Layer.provide(entry.layer, baseLayer)
-    )
-  );
-  const envLayer = moduleLayers.length > 0 ? import_effect9.Layer.mergeAll(baseLayer, ...moduleLayers) : baseLayer;
-  const finalLayer = import_effect9.Layer.unwrapScoped(
-    import_effect9.Effect.gen(function* () {
-      const scope = yield* import_effect9.Effect.scope;
-      const [patch, env] = yield* import_effect9.Effect.diffFiberRefs(import_effect9.Layer.buildWithScope(envLayer, scope));
-      const rootContext = import_effect9.Context.get(env, RootContextTag);
-      rootContext.context = env;
-      yield* import_effect9.Deferred.succeed(rootContext.ready, env);
-      const processRuntime = import_effect9.Context.get(
-        env,
-        ProcessRuntimeTag
-      );
-      yield* import_effect9.Effect.forEach(
-        config.processes,
-        (process) => import_effect9.Effect.gen(function* () {
-          const installation = yield* import_effect9.Effect.provide(
-            processRuntime.install(process, {
-              scope: { type: "app", appId },
-              enabled: true,
-              installedAt: "appRuntime"
+  const finalLayer = import_effect12.Layer.unwrapScoped(
+    import_effect12.Effect.gen(function* () {
+      const scope = yield* import_effect12.Effect.scope;
+      const [patch, env] = yield* import_effect12.Effect.diffFiberRefs(
+        import_effect12.Effect.gen(function* () {
+          const baseEnv = yield* import_effect12.Layer.buildWithScope(baseLayer, scope);
+          const moduleEnv = config.modules.length > 0 ? yield* import_effect12.Effect.provide(
+            import_effect12.Layer.buildWithScope(
+              config.modules.length === 1 ? config.modules[0].layer : config.modules.slice(1).reduce((acc, entry) => import_effect12.Layer.merge(acc, entry.layer), config.modules[0].layer),
+              scope
+            ),
+            baseEnv
+          ) : void 0;
+          const mergedEnv = moduleEnv ? import_effect12.Context.merge(baseEnv, moduleEnv) : baseEnv;
+          const rootContext = import_effect12.Context.get(mergedEnv, RootContextTag);
+          rootContext.context = mergedEnv;
+          yield* import_effect12.Deferred.succeed(rootContext.ready, mergedEnv);
+          const processRuntime = import_effect12.Context.get(
+            mergedEnv,
+            ProcessRuntimeTag
+          );
+          yield* import_effect12.Effect.forEach(
+            config.processes,
+            (process) => import_effect12.Effect.gen(function* () {
+              const installation = yield* import_effect12.Effect.provide(
+                processRuntime.install(process, {
+                  scope: { type: "app", appId },
+                  enabled: true,
+                  installedAt: "appRuntime"
+                }),
+                mergedEnv
+              );
+              if (installation === void 0) {
+                yield* import_effect12.Effect.forkScoped(
+                  import_effect12.Effect.provide(
+                    config.onError ? import_effect12.Effect.catchAllCause(process, config.onError) : process,
+                    mergedEnv
+                  )
+                );
+              }
             }),
-            env
+            { discard: true }
           );
-          if (installation === void 0) {
-            yield* import_effect9.Effect.forkScoped(
-              import_effect9.Effect.provide(config.onError ? import_effect9.Effect.catchAllCause(process, config.onError) : process, env)
-            );
-          }
-        }),
-        { discard: true }
+          return mergedEnv;
+        })
       );
-      const fiberRefsLayer = import_effect9.Layer.scopedDiscard(import_effect9.Effect.patchFiberRefs(patch));
-      return import_effect9.Layer.mergeAll(import_effect9.Layer.succeedContext(env), fiberRefsLayer);
+      const fiberRefsLayer = import_effect12.Layer.scopedDiscard(import_effect12.Effect.patchFiberRefs(patch));
+      return import_effect12.Layer.mergeAll(import_effect12.Layer.succeedContext(env), fiberRefsLayer);
     })
   );
   return {
     definition: config,
     layer: finalLayer,
-    makeRuntime: () => import_effect9.ManagedRuntime.make(finalLayer)
+    makeRuntime: () => import_effect12.ManagedRuntime.make(finalLayer)
   };
 };
 var provide = (module2, resource) => {
-  const layer4 = isLayer(resource) ? resource : import_effect9.Layer.succeed(module2, resource);
+  const layer4 = isLayer(resource) ? resource : import_effect12.Layer.succeed(module2, resource);
   return { module: module2, layer: layer4 };
 };
-var isLayer = (value) => typeof value === "object" && value !== null && import_effect9.Layer.LayerTypeId in value;
+var isLayer = (value) => typeof value === "object" && value !== null && import_effect12.Layer.LayerTypeId in value;
 
-// src/internal/runtime/core/ModuleRuntime.ts
-var import_effect43 = require("effect");
+// src/internal/runtime/core/ModuleRuntime.impl.ts
+var import_effect47 = require("effect");
 
 // src/internal/runtime/core/Lifecycle.ts
-var import_effect10 = require("effect");
-var LifecycleContext = import_effect10.Context.GenericTag("@logixjs/LifecycleManager");
+var import_effect13 = require("effect");
+var LifecycleContext = import_effect13.Context.GenericTag("@logixjs/LifecycleManager");
 
 // src/internal/runtime/core/ConvergeStaticIrCollector.ts
-var import_effect11 = require("effect");
-var currentConvergeStaticIrCollectors = import_effect11.FiberRef.unsafeMake([]);
-var appendConvergeStaticIrCollectors = (collectors) => import_effect11.Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [
+var import_effect14 = require("effect");
+var currentConvergeStaticIrCollectors = import_effect14.FiberRef.unsafeMake([]);
+var appendConvergeStaticIrCollectors = (collectors) => import_effect14.Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [
   ...current,
   ...collectors
 ]);
 
 // src/internal/runtime/core/StateTransaction.ts
-var import_effect12 = require("effect");
+var import_effect15 = require("effect");
 
 // src/internal/field-path.ts
 var isFieldPathSegment = (seg) => {
@@ -3229,26 +4504,26 @@ var isFieldPathSegment = (seg) => {
 };
 
 // src/internal/runtime/core/RuntimeKernel.ts
-var import_effect13 = require("effect");
-var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect13.Context.Tag("@logixjs/core/RuntimeServicesRuntimeConfig")() {
+var import_effect16 = require("effect");
+var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect16.Context.Tag("@logixjs/core/RuntimeServicesRuntimeConfig")() {
 };
-var RuntimeServicesProviderOverridesTagImpl = class extends import_effect13.Context.Tag("@logixjs/core/RuntimeServicesProviderOverrides")() {
+var RuntimeServicesProviderOverridesTagImpl = class extends import_effect16.Context.Tag("@logixjs/core/RuntimeServicesProviderOverrides")() {
 };
-var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect13.Context.Tag("@logixjs/core/RuntimeServicesInstanceOverrides")() {
+var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect16.Context.Tag("@logixjs/core/RuntimeServicesInstanceOverrides")() {
 };
-var FullCutoverGateModeTagImpl = class extends import_effect13.Context.Tag("@logixjs/core/FullCutoverGateMode")() {
+var FullCutoverGateModeTagImpl = class extends import_effect16.Context.Tag("@logixjs/core/FullCutoverGateMode")() {
 };
-var RuntimeServicesRegistryTagImpl = class extends import_effect13.Context.Tag("@logixjs/core/RuntimeServicesRegistry")() {
+var RuntimeServicesRegistryTagImpl = class extends import_effect16.Context.Tag("@logixjs/core/RuntimeServicesRegistry")() {
 };
 
 // src/internal/runtime/core/KernelRef.ts
-var import_effect14 = require("effect");
-var KernelImplementationRefTagImpl = class extends import_effect14.Context.Tag("@logixjs/core/KernelImplementationRef")() {
+var import_effect17 = require("effect");
+var KernelImplementationRefTagImpl = class extends import_effect17.Context.Tag("@logixjs/core/KernelImplementationRef")() {
 };
 
 // src/internal/runtime/core/RuntimeServiceBuiltins.ts
-var import_effect15 = require("effect");
-var RuntimeServiceBuiltinsTag = class extends import_effect15.Context.Tag("@logixjs/core/RuntimeServiceBuiltins")() {
+var import_effect18 = require("effect");
+var RuntimeServiceBuiltinsTag = class extends import_effect18.Context.Tag("@logixjs/core/RuntimeServiceBuiltins")() {
 };
 
 // src/internal/runtime/core/normalize.ts
@@ -3258,11 +4533,11 @@ var normalizeNonNegativeNumber = (value) => typeof value === "number" && Number.
 var normalizeBoolean = (value) => typeof value === "boolean" ? value : void 0;
 
 // src/internal/observability/evidenceCollector.ts
-var import_effect17 = require("effect");
+var import_effect20 = require("effect");
 
 // src/internal/observability/runSession.ts
-var import_effect16 = require("effect");
-var RunSessionTagImpl = class extends import_effect16.Context.Tag("@logixjs/core/RunSession")() {
+var import_effect19 = require("effect");
+var RunSessionTagImpl = class extends import_effect19.Context.Tag("@logixjs/core/RunSession")() {
 };
 var RunSessionTag = RunSessionTagImpl;
 var NEXT_RUN_SEQ_KEY = /* @__PURE__ */ Symbol.for("@logixjs/core/runSession/nextRunSeq");
@@ -3312,17 +4587,17 @@ var makeRunSession = (options) => {
     local: options?.local ?? makeRunSessionLocalState()
   };
 };
-var runSessionLayer = (session) => import_effect16.Layer.succeed(RunSessionTag, session ?? makeRunSession());
+var runSessionLayer = (session) => import_effect19.Layer.succeed(RunSessionTag, session ?? makeRunSession());
 
 // src/internal/observability/evidenceCollector.ts
-var EvidenceCollectorTagImpl = class extends import_effect17.Context.Tag("@logixjs/core/EvidenceCollector")() {
+var EvidenceCollectorTagImpl = class extends import_effect20.Context.Tag("@logixjs/core/EvidenceCollector")() {
 };
 
 // src/internal/runtime/core/ModuleRuntime.operation.ts
-var import_effect19 = require("effect");
+var import_effect22 = require("effect");
 
 // src/internal/effect-op.ts
-var import_effect18 = require("effect");
+var import_effect21 = require("effect");
 var nextGlobalOpSeq = 0;
 var nextOpSeq = () => {
   nextGlobalOpSeq += 1;
@@ -3347,33 +4622,37 @@ var make2 = (params) => ({
 var run = (op, stack) => runWithMiddleware(op, stack);
 
 // src/internal/runtime/core/ModuleRuntime.dispatch.ts
-var import_effect21 = require("effect");
+var import_effect25 = require("effect");
 
 // src/internal/runtime/core/ReducerDiagnostics.ts
-var import_effect20 = require("effect");
+var import_effect23 = require("effect");
+
+// src/internal/runtime/core/TxnOriginOverride.ts
+var import_effect24 = require("effect");
+var currentTxnOriginOverride = import_effect24.FiberRef.unsafeMake(void 0);
 
 // src/internal/runtime/core/ModuleRuntime.effects.ts
-var import_effect22 = require("effect");
+var import_effect26 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.transaction.ts
-var import_effect31 = require("effect");
+var import_effect35 = require("effect");
 
-// src/internal/state-trait/converge-in-transaction.ts
-var import_effect26 = require("effect");
+// src/internal/state-trait/converge-in-transaction.impl.ts
+var import_effect30 = require("effect");
 
 // src/internal/state-trait/converge-diagnostics.ts
-var import_effect23 = require("effect");
+var import_effect27 = require("effect");
 var SchemaAST2 = __toESM(require("effect/SchemaAST"), 1);
 
 // src/internal/state-trait/exec-vm-mode.ts
-var import_effect24 = require("effect");
-var currentExecVmMode = import_effect24.FiberRef.unsafeMake(false);
+var import_effect28 = require("effect");
+var currentExecVmMode = import_effect28.FiberRef.unsafeMake(false);
 
 // src/internal/state-trait/converge-step.ts
-var import_effect25 = require("effect");
+var import_effect29 = require("effect");
 
-// src/internal/state-trait/validate.ts
-var import_effect27 = require("effect");
+// src/internal/state-trait/validate.impl.ts
+var import_effect31 = require("effect");
 var import_mutative = require("mutative");
 var nowMs = (() => {
   const perf = globalThis.performance;
@@ -3383,42 +4662,42 @@ var nowMs = (() => {
   return () => Date.now();
 })();
 
-// src/internal/state-trait/source.ts
-var import_effect30 = require("effect");
+// src/internal/state-trait/source.impl.ts
+var import_effect34 = require("effect");
 var import_mutative2 = require("mutative");
 
 // src/internal/resource.ts
-var import_effect28 = require("effect");
-var ResourceRegistryTag = class extends import_effect28.Context.Tag("@logixjs/core/ResourceRegistry")() {
+var import_effect32 = require("effect");
+var ResourceRegistryTag = class extends import_effect32.Context.Tag("@logixjs/core/ResourceRegistry")() {
 };
 
 // src/internal/runtime/core/ReplayLog.ts
-var import_effect29 = require("effect");
-var ReplayLog = class extends import_effect29.Context.Tag("@logixjs/core/ReplayLog")() {
+var import_effect33 = require("effect");
+var ReplayLog = class extends import_effect33.Context.Tag("@logixjs/core/ReplayLog")() {
 };
-var snapshot = import_effect29.Effect.gen(function* () {
+var snapshot = import_effect33.Effect.gen(function* () {
   const log = yield* ReplayLog;
   return yield* log.snapshot;
 });
-var resetCursor = import_effect29.Effect.gen(function* () {
+var resetCursor = import_effect33.Effect.gen(function* () {
   const log = yield* ReplayLog;
   yield* log.resetCursor;
 });
 
 // src/internal/runtime/core/ModuleRuntime.concurrencyPolicy.ts
-var import_effect32 = require("effect");
+var import_effect36 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.txnLanePolicy.ts
-var import_effect33 = require("effect");
+var import_effect37 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.traitConvergeConfig.ts
-var import_effect34 = require("effect");
+var import_effect38 = require("effect");
 
 // src/internal/state-trait/build.ts
 var SchemaAST3 = __toESM(require("effect/SchemaAST"), 1);
 
 // src/internal/runtime/core/ModuleRuntime.internalHooks.ts
-var import_effect35 = require("effect");
+var import_effect39 = require("effect");
 
 // src/internal/runtime/core/ReadQuery.ts
 function isReadQuery(input) {
@@ -3428,25 +4707,25 @@ function isReadQuery(input) {
 }
 
 // src/internal/runtime/core/SelectorGraph.ts
-var import_effect36 = require("effect");
+var import_effect40 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.registry.ts
 var runtimeByInstanceKey = /* @__PURE__ */ new Map();
 var getRuntimeByModuleAndInstance = (moduleId, instanceId) => runtimeByInstanceKey.get(`${moduleId}::${instanceId}`);
 
 // src/internal/runtime/core/ModuleRuntime.txnQueue.ts
-var import_effect37 = require("effect");
+var import_effect41 = require("effect");
 
 // src/internal/runtime/core/ModuleRuntime.logics.ts
-var import_effect41 = require("effect");
+var import_effect45 = require("effect");
 
 // src/internal/runtime/core/LifecycleDiagnostics.ts
-var import_effect38 = require("effect");
+var import_effect42 = require("effect");
 
 // src/internal/runtime/core/LogicDiagnostics.ts
-var import_effect39 = require("effect");
-var LogicPhaseServiceTag = import_effect39.Context.GenericTag("@logixjs/LogicPhaseService");
-var LogicUnitServiceTag = class extends import_effect39.Context.Tag("@logixjs/LogicUnitService")() {
+var import_effect43 = require("effect");
+var LogicPhaseServiceTag = import_effect43.Context.GenericTag("@logixjs/LogicPhaseService");
+var LogicUnitServiceTag = class extends import_effect43.Context.Tag("@logixjs/LogicUnitService")() {
 };
 var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(new Error(`[LogicPhaseError] ${api} is not allowed in ${phase} phase (kind=${kind}).`), {
   _tag: "LogicPhaseError",
@@ -3457,219 +4736,15 @@ var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(new Erro
 });
 
 // src/internal/runtime/core/Platform.ts
-var import_effect40 = require("effect");
-var Tag = import_effect40.Context.GenericTag("@logixjs/Platform");
+var import_effect44 = require("effect");
+var Tag = import_effect44.Context.GenericTag("@logixjs/Platform");
 
 // src/internal/runtime/core/ConcurrencyDiagnostics.ts
-var import_effect42 = require("effect");
-var nowMs2 = import_effect42.Effect.clockWith((clock) => clock.currentTimeMillis);
-
-// src/Debug.ts
-var import_effect45 = require("effect");
-
-// src/internal/runtime/core/DevtoolsHub.ts
-var import_effect44 = require("effect");
-var instances = /* @__PURE__ */ new Map();
-var latestStates = /* @__PURE__ */ new Map();
-var latestTraitSummaries = /* @__PURE__ */ new Map();
-var instanceLabels = /* @__PURE__ */ new Map();
-var convergeStaticIrByDigest = /* @__PURE__ */ new Map();
-var liveInstanceKeys = /* @__PURE__ */ new Set();
-var exportBudget = {
-  dropped: 0,
-  oversized: 0
-};
-var lastRunTs = 0;
-var lastRunTsSeq = 0;
-var nextRunId = () => {
-  const ts = Date.now();
-  if (ts === lastRunTs) {
-    lastRunTsSeq += 1;
-  } else {
-    lastRunTs = ts;
-    lastRunTsSeq = 0;
-  }
-  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
-};
-var currentRunId = nextRunId();
-var nextSeq = 1;
-var bufferSize = 500;
-var ringBuffer = [];
-var ringBufferSeq = [];
-var snapshotToken = 0;
-var ensureRingBufferSize = () => {
-  if (bufferSize <= 0) {
-    ringBuffer.length = 0;
-    ringBufferSeq.length = 0;
-    return;
-  }
-  if (ringBuffer.length <= bufferSize) return;
-  const excess = ringBuffer.length - bufferSize;
-  ringBuffer.splice(0, excess);
-  ringBufferSeq.splice(0, excess);
-};
-var trimRingBufferIfNeeded = () => {
-  if (bufferSize <= 0) {
-    ringBuffer.length = 0;
-    ringBufferSeq.length = 0;
-    return;
-  }
-  if (bufferSize <= 64) {
-    ensureRingBufferSize();
-    return;
-  }
-  const slack = Math.min(1024, Math.floor(bufferSize / 2));
-  const threshold = bufferSize + Math.max(1, slack);
-  if (ringBuffer.length <= threshold) return;
-  const excess = ringBuffer.length - bufferSize;
-  ringBuffer.splice(0, excess);
-  ringBufferSeq.splice(0, excess);
-};
-var currentSnapshot = {
-  snapshotToken,
-  instances,
-  events: ringBuffer,
-  latestStates,
-  latestTraitSummaries,
-  exportBudget
-};
-var listeners = /* @__PURE__ */ new Set();
-var notifyScheduled = false;
-var scheduleNotify = () => {
-  if (notifyScheduled) return;
-  notifyScheduled = true;
-  queueMicrotask(() => {
-    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 registerConvergeStaticIr = (ir) => {
-  convergeStaticIrByDigest.set(ir.staticIrDigest, ir);
-};
-var devtoolsHubConvergeStaticIrCollector = {
-  register: registerConvergeStaticIr
-};
-var devtoolsHubSink = {
-  record: (event) => import_effect44.Effect.gen(function* () {
-    const level = yield* import_effect44.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 runtimeLabel2 = event.runtimeLabel ?? "unknown";
-      const instanceId = event.instanceId;
-      const key = `${runtimeLabel2}::${moduleId}`;
-      const prev = instances.get(key) ?? 0;
-      if (event.type === "module:init") {
-        instances.set(key, prev + 1);
-        changed = true;
-        if (instanceId) {
-          const instanceKey = `${runtimeLabel2}::${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 = `${runtimeLabel2}::${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 runtimeLabel2 = ref.runtimeLabel ?? "unknown";
-      const key = `${runtimeLabel2}::${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();
-    }
-  })
-};
+var import_effect46 = require("effect");
+var nowMs2 = import_effect46.Effect.clockWith((clock) => clock.currentTimeMillis);
 
 // src/Debug.ts
+var import_effect48 = require("effect");
 var internal2 = {
   currentDebugSinks,
   currentRuntimeLabel,
@@ -3677,7 +4752,7 @@ var internal2 = {
   currentTraitConvergeDiagnosticsSampling,
   toRuntimeDebugEventRef
 };
-var diagnosticsLevel = (level) => import_effect45.Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
+var diagnosticsLevel = (level) => import_effect48.Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
 var traitConvergeDiagnosticsSampling2 = (config) => traitConvergeDiagnosticsSampling(config);
 var record2 = record;
 var resolveMode = (mode) => {
@@ -3702,16 +4777,16 @@ var layer2 = (options) => {
       }
     }
   })();
-  return diagnostics ? import_effect45.Layer.mergeAll(sinks, diagnosticsLevel(diagnostics)) : sinks;
+  return diagnostics ? import_effect48.Layer.mergeAll(sinks, diagnosticsLevel(diagnostics)) : sinks;
 };
-var appendSinks = (sinks) => import_effect45.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [
+var appendSinks = (sinks) => import_effect48.Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [
   ...current,
   ...sinks
 ]);
 function devtoolsHubLayer(baseOrOptions, maybeOptions) {
   const isLayerValue = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
   const hasBase = isLayerValue(baseOrOptions);
-  const base = hasBase ? baseOrOptions : import_effect45.Layer.empty;
+  const base = hasBase ? baseOrOptions : import_effect48.Layer.empty;
   const options = hasBase ? maybeOptions : baseOrOptions;
   configureDevtoolsHub(options);
   const append = appendSinks([devtoolsHubSink]);
@@ -3719,24 +4794,24 @@ function devtoolsHubLayer(baseOrOptions, maybeOptions) {
     devtoolsHubConvergeStaticIrCollector
   ]);
   const enableExportableDiagnostics = diagnosticsLevel(options?.diagnosticsLevel ?? "light");
-  const convergeSamplingLayer = options?.traitConvergeDiagnosticsSampling ? traitConvergeDiagnosticsSampling2(options.traitConvergeDiagnosticsSampling) : import_effect45.Layer.empty;
-  return import_effect45.Layer.provideMerge(
-    import_effect45.Layer.mergeAll(append, enableExportableDiagnostics, convergeSamplingLayer, appendConvergeStaticIr),
+  const convergeSamplingLayer = options?.traitConvergeDiagnosticsSampling ? traitConvergeDiagnosticsSampling2(options.traitConvergeDiagnosticsSampling) : import_effect48.Layer.empty;
+  return import_effect48.Layer.provideMerge(
+    import_effect48.Layer.mergeAll(append, enableExportableDiagnostics, convergeSamplingLayer, appendConvergeStaticIr),
     base
   );
 }
-var runtimeLabel = (label) => import_effect45.Layer.fiberRefLocallyScopedWith(internal2.currentRuntimeLabel, () => label);
+var runtimeLabel = (label) => import_effect48.Layer.fiberRefLocallyScopedWith(internal2.currentRuntimeLabel, () => label);
 
 // src/Middleware.ts
-var import_effect46 = require("effect");
-var makeDebugLogger = (config) => (op) => import_effect46.Effect.gen(function* () {
+var import_effect49 = require("effect");
+var makeDebugLogger = (config) => (op) => import_effect49.Effect.gen(function* () {
   if (op.meta?.policy?.disableObservers) {
     return yield* op.effect;
   }
   if (config?.logger) {
     config.logger(op);
   } else {
-    yield* import_effect46.Effect.logDebug(`[EffectOp] kind=${op.kind} name=${op.name}`);
+    yield* import_effect49.Effect.logDebug(`[EffectOp] kind=${op.kind} name=${op.name}`);
   }
   return yield* op.effect;
 });
@@ -3744,7 +4819,7 @@ var applyDebug = (stack, config) => [
   ...stack,
   makeDebugLogger(config)
 ];
-var makeDebugObserver = (config) => (op) => import_effect46.Effect.gen(function* () {
+var makeDebugObserver = (config) => (op) => import_effect49.Effect.gen(function* () {
   if (op.meta?.policy?.disableObservers) {
     return yield* op.effect;
   }
@@ -3787,15 +4862,15 @@ var withDebug = (stack, options) => {
 };
 
 // src/ScopeRegistry.ts
-var import_effect47 = require("effect");
+var import_effect50 = require("effect");
 
 // src/Env.ts
 var isDevEnv2 = () => isDevEnv();
 
 // src/ScopeRegistry.ts
-var ScopeRegistryTag = class extends import_effect47.Context.Tag("@logixjs/core/ScopeRegistry")() {
+var ScopeRegistryTag = class extends import_effect50.Context.Tag("@logixjs/core/ScopeRegistry")() {
 };
-var ScopedRuntimeTag = class extends import_effect47.Context.Tag("@logixjs/core/ScopeRegistry/ScopedRuntime")() {
+var ScopedRuntimeTag = class extends import_effect50.Context.Tag("@logixjs/core/ScopeRegistry/ScopedRuntime")() {
 };
 var makeRegistry = () => {
   let nextLeaseId = 0;
@@ -3874,15 +4949,15 @@ var makeRegistry = () => {
   };
   return { register, get, clearToken, clearScope, clearAll };
 };
-var layer3 = () => import_effect47.Layer.succeed(ScopeRegistryTag, makeRegistry());
+var layer3 = () => import_effect50.Layer.succeed(ScopeRegistryTag, makeRegistry());
 
 // src/internal/runtime/core/configValidation.ts
-var import_effect48 = require("effect");
-var PositiveIntSchema = import_effect48.Schema.Int.pipe(import_effect48.Schema.positive());
-var PositiveNumberSchema = import_effect48.Schema.Number.pipe(import_effect48.Schema.positive());
-var ConvergeModeSchema = import_effect48.Schema.Union(import_effect48.Schema.Literal("auto"), import_effect48.Schema.Literal("full"), import_effect48.Schema.Literal("dirty"));
-var InstrumentationSchema = import_effect48.Schema.Union(import_effect48.Schema.Literal("full"), import_effect48.Schema.Literal("light"));
-var ConcurrencyLimitSchema = import_effect48.Schema.Union(import_effect48.Schema.Literal("unbounded"), PositiveIntSchema);
+var import_effect51 = require("effect");
+var PositiveIntSchema = import_effect51.Schema.Int.pipe(import_effect51.Schema.positive());
+var PositiveNumberSchema = import_effect51.Schema.Number.pipe(import_effect51.Schema.positive());
+var ConvergeModeSchema = import_effect51.Schema.Union(import_effect51.Schema.Literal("auto"), import_effect51.Schema.Literal("full"), import_effect51.Schema.Literal("dirty"));
+var InstrumentationSchema = import_effect51.Schema.Union(import_effect51.Schema.Literal("full"), import_effect51.Schema.Literal("light"));
+var ConcurrencyLimitSchema = import_effect51.Schema.Union(import_effect51.Schema.Literal("unbounded"), PositiveIntSchema);
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var warnDevOnly = (label, issues) => {
   if (!isDevEnv()) return;
@@ -3903,7 +4978,7 @@ var collectUnknownKeys = (obj, allowed, prefix) => {
 var validateConcurrencyPolicyPatch = (obj, prefix) => {
   const issues = [];
   if ("concurrencyLimit" in obj && obj.concurrencyLimit != null) {
-    if (!import_effect48.Schema.is(ConcurrencyLimitSchema)(obj.concurrencyLimit)) {
+    if (!import_effect51.Schema.is(ConcurrencyLimitSchema)(obj.concurrencyLimit)) {
       issues.push(`${prefix}concurrencyLimit: expected positive int | "unbounded"`);
     }
   }
@@ -4025,7 +5100,7 @@ var warnInvalidConcurrencyPolicyPatchDevOnly = (value, label) => {
 var validateStateTransactionTraitOverrides = (obj, prefix) => {
   const issues = [];
   if ("traitConvergeMode" in obj && obj.traitConvergeMode != null) {
-    if (!import_effect48.Schema.is(ConvergeModeSchema)(obj.traitConvergeMode)) {
+    if (!import_effect51.Schema.is(ConvergeModeSchema)(obj.traitConvergeMode)) {
       issues.push(`${prefix}traitConvergeMode: expected "auto" | "full" | "dirty"`);
     }
   }
@@ -4154,7 +5229,7 @@ var warnInvalidStateTransactionRuntimeConfigDevOnly = (value, label) => {
     )
   );
   if ("instrumentation" in value && value.instrumentation != null) {
-    if (!import_effect48.Schema.is(InstrumentationSchema)(value.instrumentation)) {
+    if (!import_effect51.Schema.is(InstrumentationSchema)(value.instrumentation)) {
       issues.push(`instrumentation: expected "full" | "light"`);
     }
   }
@@ -4331,14 +5406,14 @@ var warnInvalidStateTransactionOverridesDevOnly = (value, label) => {
 };
 
 // src/internal/runtime/core/runner/ProgramRunner.ts
-var import_effect57 = require("effect");
+var import_effect60 = require("effect");
 
 // src/internal/runtime/core/BoundApiRuntime.ts
-var import_effect53 = require("effect");
+var import_effect56 = require("effect");
 
 // src/internal/action.ts
-var import_effect49 = require("effect");
-var isActionToken = (value) => typeof value === "function" && value._kind === "ActionToken" && typeof value.tag === "string" && import_effect49.Schema.isSchema(value.schema);
+var import_effect52 = require("effect");
+var isActionToken = (value) => typeof value === "function" && value._kind === "ActionToken" && typeof value.tag === "string" && import_effect52.Schema.isSchema(value.schema);
 
 // src/internal/runtime/core/mutativePatches.ts
 var import_mutative3 = require("mutative");
@@ -4384,9 +5459,9 @@ var mutateWithPatchPaths = (base, mutator) => {
 };
 
 // src/internal/runtime/core/FlowRuntime.ts
-var import_effect50 = require("effect");
-var getMiddlewareStack2 = () => import_effect50.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
-  import_effect50.Effect.map((maybe) => import_effect50.Option.isSome(maybe) ? maybe.value.stack : [])
+var import_effect53 = require("effect");
+var getMiddlewareStack2 = () => import_effect53.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect53.Effect.map((maybe) => import_effect53.Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var getRuntimeScope = (runtime) => {
   if (!runtime) return {};
@@ -4400,8 +5475,8 @@ var getRuntimeScope = (runtime) => {
 var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
 var make5 = (runtime, runtimeInternals) => {
   const scope = getRuntimeScope(runtime);
-  const resolveConcurrencyLimit2 = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect50.Effect.map((p) => p.concurrencyLimit)) : import_effect50.Effect.succeed(16);
-  const runAsFlowOp = (name, payload, eff, options) => import_effect50.Effect.gen(function* () {
+  const resolveConcurrencyLimit2 = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect53.Effect.map((p) => p.concurrencyLimit)) : import_effect53.Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => import_effect53.Effect.gen(function* () {
     const stack = yield* getMiddlewareStack2();
     const meta = {
       ...options?.meta ?? {},
@@ -4412,8 +5487,8 @@ var make5 = (runtime, runtimeInternals) => {
       instanceId: scope.instanceId
     };
     if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
-      const sessionOpt = yield* import_effect50.Effect.serviceOption(RunSessionTag);
-      if (import_effect50.Option.isSome(sessionOpt)) {
+      const sessionOpt = yield* import_effect53.Effect.serviceOption(RunSessionTag);
+      if (import_effect53.Option.isSome(sessionOpt)) {
         const key = meta.instanceId ?? "global";
         meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
       }
@@ -4428,21 +5503,21 @@ var make5 = (runtime, runtimeInternals) => {
     return yield* run(op, stack);
   });
   const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
-  const runStreamSequential = (eff, options) => (stream) => import_effect50.Stream.runForEach(
+  const runStreamSequential = (eff, options) => (stream) => import_effect53.Stream.runForEach(
     stream,
     (payload) => runAsFlowOp("flow.run", payload, runEffect(eff)(payload), options)
   );
-  const runStreamParallel = (eff, options) => (stream) => import_effect50.Effect.gen(function* () {
+  const runStreamParallel = (eff, options) => (stream) => import_effect53.Effect.gen(function* () {
     const concurrency = yield* resolveConcurrencyLimit2();
-    return yield* import_effect50.Stream.runDrain(
+    return yield* import_effect53.Stream.runDrain(
       stream.pipe(
-        import_effect50.Stream.mapEffect(
+        import_effect53.Stream.mapEffect(
           (payload) => runAsFlowOp("flow.runParallel", payload, runEffect(eff)(payload), options),
           { concurrency }
         )
       )
     ).pipe(
-      import_effect50.Effect.catchAllCause(
+      import_effect53.Effect.catchAllCause(
         (cause) => record({
           type: "diagnostic",
           moduleId: scope.moduleId,
@@ -4456,25 +5531,25 @@ var make5 = (runtime, runtimeInternals) => {
             kind: "flow",
             name: "runParallel"
           }
-        }).pipe(import_effect50.Effect.zipRight(import_effect50.Effect.failCause(cause)))
+        }).pipe(import_effect53.Effect.zipRight(import_effect53.Effect.failCause(cause)))
       )
     );
   });
   return {
-    fromAction: (predicate) => runtime.actions$.pipe(import_effect50.Stream.filter(predicate)),
+    fromAction: (predicate) => runtime.actions$.pipe(import_effect53.Stream.filter(predicate)),
     fromState: (selectorOrQuery) => runtime.changes(isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),
-    debounce: (ms) => (stream) => import_effect50.Stream.debounce(stream, ms),
-    throttle: (ms) => (stream) => import_effect50.Stream.throttle(stream, {
+    debounce: (ms) => (stream) => import_effect53.Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => import_effect53.Stream.throttle(stream, {
       cost: () => 1,
       units: 1,
       duration: ms,
       strategy: "enforce"
     }),
-    filter: (predicate) => (stream) => import_effect50.Stream.filter(stream, predicate),
+    filter: (predicate) => (stream) => import_effect53.Stream.filter(stream, predicate),
     run: (eff, options) => (stream) => runStreamSequential(eff, options)(stream),
     runParallel: (eff, options) => (stream) => runStreamParallel(eff, options)(stream),
-    runLatest: (eff, options) => (stream) => import_effect50.Stream.runDrain(
-      import_effect50.Stream.map(
+    runLatest: (eff, options) => (stream) => import_effect53.Stream.runDrain(
+      import_effect53.Stream.map(
         stream,
         (payload) => runAsFlowOp(
           "flow.runLatest",
@@ -4483,16 +5558,16 @@ var make5 = (runtime, runtimeInternals) => {
           options
         )
       ).pipe(
-        import_effect50.Stream.flatMap((effect) => import_effect50.Stream.fromEffect(effect), {
+        import_effect53.Stream.flatMap((effect) => import_effect53.Stream.fromEffect(effect), {
           switch: true
         })
       )
     ),
-    runExhaust: (eff, options) => (stream) => import_effect50.Effect.gen(function* () {
+    runExhaust: (eff, options) => (stream) => import_effect53.Effect.gen(function* () {
       const concurrency = yield* resolveConcurrencyLimit2();
-      const busyRef = yield* import_effect50.Ref.make(false);
-      const mapper = (payload) => import_effect50.Effect.gen(function* () {
-        const acquired = yield* import_effect50.Ref.modify(
+      const busyRef = yield* import_effect53.Ref.make(false);
+      const mapper = (payload) => import_effect53.Effect.gen(function* () {
+        const acquired = yield* import_effect53.Ref.modify(
           busyRef,
           (busy) => busy ? [false, busy] : [true, true]
         );
@@ -4507,16 +5582,16 @@ var make5 = (runtime, runtimeInternals) => {
             options
           );
         } finally {
-          yield* import_effect50.Ref.set(busyRef, false);
+          yield* import_effect53.Ref.set(busyRef, false);
         }
       });
-      return yield* import_effect50.Stream.runDrain(stream.pipe(import_effect50.Stream.mapEffect(mapper, { concurrency })));
+      return yield* import_effect53.Stream.runDrain(stream.pipe(import_effect53.Stream.mapEffect(mapper, { concurrency })));
     })
   };
 };
 
 // src/internal/runtime/core/MatchBuilder.ts
-var import_effect51 = require("effect");
+var import_effect54 = require("effect");
 var makeMatch = (value) => {
   let result;
   const chain = {
@@ -4535,7 +5610,7 @@ var makeMatch = (value) => {
       if (result) {
         return result;
       }
-      return import_effect51.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
+      return import_effect54.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
     }
   };
   return chain;
@@ -4558,14 +5633,14 @@ var makeMatchTag = (value) => {
       if (result) {
         return result;
       }
-      return import_effect51.Effect.dieMessage("[FluentMatchTag] Non-exhaustive match: no tag handler matched value");
+      return import_effect54.Effect.dieMessage("[FluentMatchTag] Non-exhaustive match: no tag handler matched value");
     }
   };
   return chain;
 };
 
 // src/internal/root.ts
-var import_effect52 = require("effect");
+var import_effect55 = require("effect");
 var tagIdOf = (tag) => typeof tag?.id === "string" ? String(tag.id) : typeof tag?.key === "string" ? String(tag.key) : "<unknown tag>";
 var makeMissingRootProviderError = (tag, entrypoint, extra) => {
   const dev = isDevEnv();
@@ -4596,19 +5671,19 @@ ${extra}` : "",
   err.fix = fix;
   return err;
 };
-var resolve2 = (tag, options) => import_effect52.Effect.gen(function* () {
+var resolve2 = (tag, options) => import_effect55.Effect.gen(function* () {
   const entrypoint = options?.entrypoint ?? "logic.root.resolve";
   const root = yield* RootContextTag;
   const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : void 0);
   if (!rootContext) {
-    return yield* import_effect52.Effect.die(
+    return yield* import_effect55.Effect.die(
       makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
     );
   }
   try {
-    return import_effect52.Context.get(rootContext, tag);
+    return import_effect55.Context.get(rootContext, tag);
   } catch {
-    return yield* import_effect52.Effect.die(makeMissingRootProviderError(tag, entrypoint));
+    return yield* import_effect55.Effect.die(makeMissingRootProviderError(tag, entrypoint));
   }
 });
 
@@ -4627,7 +5702,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
       debounce: (ms) => LogicBuilderFactory(runtime, runtimeInternals)(flowApi.debounce(ms)(stream), triggerName),
       throttle: (ms) => LogicBuilderFactory(runtime, runtimeInternals)(flowApi.throttle(ms)(stream), triggerName),
       filter: (predicate) => LogicBuilderFactory(runtime, runtimeInternals)(flowApi.filter(predicate)(stream), triggerName),
-      map: (f) => LogicBuilderFactory(runtime, runtimeInternals)(stream.pipe(import_effect53.Stream.map(f)), triggerName),
+      map: (f) => LogicBuilderFactory(runtime, runtimeInternals)(stream.pipe(import_effect56.Stream.map(f)), triggerName),
       run(eff, options) {
         return flowApi.run(eff, options)(stream);
       },
@@ -4640,8 +5715,8 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
       runParallel(eff, options) {
         return flowApi.runParallel(eff, options)(stream);
       },
-      runFork: (eff) => import_effect53.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect53.Effect.asVoid),
-      runParallelFork: (eff) => import_effect53.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect53.Effect.asVoid),
+      runFork: (eff) => import_effect56.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect56.Effect.asVoid),
+      runParallelFork: (eff) => import_effect56.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect56.Effect.asVoid),
       runTask: (config) => makeTaskRunner(stream, "task", taskRunnerRuntime, {
         ...config,
         triggerName: config.triggerName ?? triggerName
@@ -4659,20 +5734,20 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
         triggerName: config.triggerName ?? triggerName
       }),
       toStream: () => stream,
-      update: (reducer) => import_effect53.Stream.runForEach(
+      update: (reducer) => import_effect56.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:update",
             name: triggerName
           },
-          () => import_effect53.Effect.gen(function* () {
+          () => import_effect56.Effect.gen(function* () {
             const prev = yield* runtime.getState;
             const next = reducer(prev, payload);
-            if (import_effect53.Effect.isEffect(next)) {
-              const exit = yield* import_effect53.Effect.exit(next);
+            if (import_effect56.Effect.isEffect(next)) {
+              const exit = yield* import_effect56.Effect.exit(next);
               if (exit._tag === "Failure") {
-                yield* import_effect53.Effect.logError("Flow error", exit.cause);
+                yield* import_effect56.Effect.logError("Flow error", exit.cause);
                 return;
               }
               yield* runtime.setState(exit.value);
@@ -4681,15 +5756,15 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             yield* runtime.setState(next);
           })
         )
-      ).pipe(import_effect53.Effect.catchAllCause((cause) => import_effect53.Effect.logError("Flow error", cause))),
-      mutate: (reducer) => import_effect53.Stream.runForEach(
+      ).pipe(import_effect56.Effect.catchAllCause((cause) => import_effect56.Effect.logError("Flow error", cause))),
+      mutate: (reducer) => import_effect56.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:mutate",
             name: triggerName
           },
-          () => import_effect53.Effect.gen(function* () {
+          () => import_effect56.Effect.gen(function* () {
             const prev = yield* runtime.getState;
             const recordPatch2 = runtimeInternals.txn.recordStatePatch;
             const updateDraft2 = runtimeInternals.txn.updateDraft;
@@ -4702,7 +5777,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             updateDraft2(nextState);
           })
         )
-      ).pipe(import_effect53.Effect.catchAllCause((cause) => import_effect53.Effect.logError("Flow error", cause)))
+      ).pipe(import_effect56.Effect.catchAllCause((cause) => import_effect56.Effect.logError("Flow error", cause)))
     };
     const pipe = function() {
       const fns = arguments;
@@ -4732,19 +5807,19 @@ function make6(shape, runtime, options) {
   };
   const flowApi = make5(runtime, runtimeInternals);
   const makeIntentBuilder = (runtime_) => LogicBuilderFactory(runtime_, runtimeInternals);
-  const withLifecycle = (available, missing) => import_effect53.Effect.serviceOption(LifecycleContext).pipe(
-    import_effect53.Effect.flatMap(
-      (maybe) => import_effect53.Option.match(maybe, {
+  const withLifecycle = (available, missing) => import_effect56.Effect.serviceOption(LifecycleContext).pipe(
+    import_effect56.Effect.flatMap(
+      (maybe) => import_effect56.Option.match(maybe, {
         onSome: available,
         onNone: missing
       })
     )
   );
-  const withPlatform = (invoke) => import_effect53.Effect.serviceOption(Tag).pipe(
-    import_effect53.Effect.flatMap(
-      (maybe) => import_effect53.Option.match(maybe, {
+  const withPlatform = (invoke) => import_effect56.Effect.serviceOption(Tag).pipe(
+    import_effect56.Effect.flatMap(
+      (maybe) => import_effect56.Option.match(maybe, {
         onSome: invoke,
-        onNone: () => import_effect53.Effect.void
+        onNone: () => import_effect56.Effect.void
       })
     )
   );
@@ -4759,12 +5834,12 @@ function make6(shape, runtime, options) {
     kind: "lifecycle_in_run"
   });
   const createIntentBuilder = (stream, triggerName) => makeIntentBuilder(runtime)(stream, triggerName);
-  const onceInRunSession2 = (key) => import_effect53.Effect.serviceOption(RunSessionTag).pipe(
-    import_effect53.Effect.map((maybe) => import_effect53.Option.isSome(maybe) ? maybe.value.local.once(key) : true)
+  const onceInRunSession2 = (key) => import_effect56.Effect.serviceOption(RunSessionTag).pipe(
+    import_effect56.Effect.map((maybe) => import_effect56.Option.isSome(maybe) ? maybe.value.local.once(key) : true)
   );
   let cachedDiagnosticsLevel;
   const isModuleLike = (value) => Boolean(
-    value && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value && import_effect53.Context.isTag(value.tag)
+    value && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value && import_effect56.Context.isTag(value.tag)
   );
   const buildModuleHandle = (tag, rt) => {
     const actionsProxy = new Proxy(
@@ -4777,7 +5852,7 @@ function make6(shape, runtime, options) {
       }
     );
     const handle = {
-      read: (selector) => import_effect53.Effect.map(rt.getState, selector),
+      read: (selector) => import_effect56.Effect.map(rt.getState, selector),
       changes: rt.changes,
       dispatch: rt.dispatch,
       actions$: rt.actions$,
@@ -4787,7 +5862,7 @@ function make6(shape, runtime, options) {
     const extend = tag?.[EXTEND_HANDLE];
     return typeof extend === "function" ? extend(rt, handle) ?? handle : handle;
   };
-  const emitModuleDescriptorOnce = (module2, rt) => import_effect53.Effect.gen(function* () {
+  const emitModuleDescriptorOnce = (module2, rt) => import_effect56.Effect.gen(function* () {
     if (cachedDiagnosticsLevel === "off") return;
     const key = `module_descriptor:${String(rt.instanceId ?? "unknown")}`;
     const shouldEmit = yield* onceInRunSession2(key);
@@ -4827,7 +5902,7 @@ function make6(shape, runtime, options) {
       data
     });
   });
-  const resolveModuleRuntime = (tag) => import_effect53.Effect.gen(function* () {
+  const resolveModuleRuntime = (tag) => import_effect56.Effect.gen(function* () {
     const requestedModuleId = typeof tag?.id === "string" ? tag.id : void 0;
     const fromModuleId = typeof options?.moduleId === "string" ? options.moduleId : runtime.moduleId;
     if (requestedModuleId && requestedModuleId === runtime.moduleId) {
@@ -4838,8 +5913,8 @@ function make6(shape, runtime, options) {
       return fromImports;
     }
     if (typeof options?.moduleId !== "string") {
-      const fromEnv = yield* import_effect53.Effect.serviceOption(tag);
-      if (import_effect53.Option.isSome(fromEnv)) {
+      const fromEnv = yield* import_effect56.Effect.serviceOption(tag);
+      if (import_effect56.Option.isSome(fromEnv)) {
         return fromEnv.value;
       }
     }
@@ -4874,23 +5949,23 @@ function make6(shape, runtime, options) {
     };
     err.fix = fix;
     err.name = "MissingModuleRuntimeError";
-    return yield* import_effect53.Effect.die(err);
+    return yield* import_effect56.Effect.die(err);
   });
   const stateApi = {
     read: runtime.getState,
-    update: (f) => import_effect53.Effect.gen(function* () {
-      const inTxn = yield* import_effect53.FiberRef.get(inSyncTransactionFiber);
+    update: (f) => import_effect56.Effect.gen(function* () {
+      const inTxn = yield* import_effect56.FiberRef.get(inSyncTransactionFiber);
       if (inTxn) {
         const prev = yield* runtime.getState;
         return yield* runtime.setState(f(prev));
       }
-      const body = () => import_effect53.Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
+      const body = () => import_effect56.Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
       return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "update" }, body) : body();
     }),
-    mutate: (f) => import_effect53.Effect.gen(function* () {
+    mutate: (f) => import_effect56.Effect.gen(function* () {
       const recordPatch2 = runtimeInternals?.txn.recordStatePatch;
       const updateDraft2 = runtimeInternals?.txn.updateDraft;
-      const inTxn = yield* import_effect53.FiberRef.get(inSyncTransactionFiber);
+      const inTxn = yield* import_effect56.FiberRef.get(inSyncTransactionFiber);
       if (inTxn) {
         const prev = yield* runtime.getState;
         const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
@@ -4902,7 +5977,7 @@ function make6(shape, runtime, options) {
         updateDraft2?.(nextState);
         return;
       }
-      const body = () => import_effect53.Effect.gen(function* () {
+      const body = () => import_effect56.Effect.gen(function* () {
         const prev = yield* runtime.getState;
         const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
           f(draft);
@@ -4951,13 +6026,13 @@ function make6(shape, runtime, options) {
   const matchApi = (value) => makeMatch(value);
   const matchTagApi = (value) => makeMatchTag(value);
   const reducer = (tag, fn) => {
-    return import_effect53.Effect.sync(() => {
+    return import_effect56.Effect.sync(() => {
       runtimeInternals.txn.registerReducer(String(tag), fn);
     });
   };
-  const effect = (token, handler) => import_effect53.Effect.gen(function* () {
+  const effect = (token, handler) => import_effect56.Effect.gen(function* () {
     if (!isActionToken(token)) {
-      return yield* import_effect53.Effect.dieMessage("[BoundApi.effect] token must be an ActionToken");
+      return yield* import_effect56.Effect.dieMessage("[BoundApi.effect] token must be an ActionToken");
     }
     const phase = getCurrentPhase();
     const logicUnit = options?.logicUnit;
@@ -4997,56 +6072,56 @@ function make6(shape, runtime, options) {
           return emitSetupOnlyViolation("$.lifecycle.onInitRequired");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect53.Effect.void;
+        return import_effect56.Effect.void;
       },
       onStart: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onStart");
         }
         runtimeInternals.lifecycle.registerStart(eff);
-        return import_effect53.Effect.void;
+        return import_effect56.Effect.void;
       },
       onInit: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onInit");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect53.Effect.void;
+        return import_effect56.Effect.void;
       },
       onDestroy: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onDestroy");
         }
         runtimeInternals.lifecycle.registerDestroy(eff);
-        return import_effect53.Effect.void;
+        return import_effect56.Effect.void;
       },
       onError: (handler) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onError");
         }
         runtimeInternals.lifecycle.registerOnError(handler);
-        return import_effect53.Effect.void;
+        return import_effect56.Effect.void;
       },
       onSuspend: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onSuspend");
         }
-        runtimeInternals.lifecycle.registerPlatformSuspend(import_effect53.Effect.asVoid(eff));
-        return import_effect53.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformSuspend(import_effect56.Effect.asVoid(eff));
+        return import_effect56.Effect.void;
       },
       onResume: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onResume");
         }
-        runtimeInternals.lifecycle.registerPlatformResume(import_effect53.Effect.asVoid(eff));
-        return import_effect53.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformResume(import_effect56.Effect.asVoid(eff));
+        return import_effect56.Effect.void;
       },
       onReset: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onReset");
         }
-        runtimeInternals.lifecycle.registerPlatformReset(import_effect53.Effect.asVoid(eff));
-        return import_effect53.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformReset(import_effect56.Effect.asVoid(eff));
+        return import_effect56.Effect.void;
       }
     },
     traits: {
@@ -5080,14 +6155,14 @@ function make6(shape, runtime, options) {
         });
       },
       source: {
-        refresh: (fieldPath, options2) => import_effect53.Effect.gen(function* () {
+        refresh: (fieldPath, options2) => import_effect56.Effect.gen(function* () {
           const handler = runtimeInternals.traits.getSourceRefreshHandler(fieldPath);
           if (!handler) {
-            return yield* import_effect53.Effect.void;
+            return yield* import_effect56.Effect.void;
           }
           const force = options2?.force === true;
-          const runHandler = (state) => force ? import_effect53.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
-          const inTxn = yield* import_effect53.FiberRef.get(inSyncTransactionFiber);
+          const runHandler = (state) => force ? import_effect56.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
+          const inTxn = yield* import_effect56.FiberRef.get(inSyncTransactionFiber);
           if (inTxn) {
             const state = yield* runtime.getState;
             return yield* runHandler(state);
@@ -5097,7 +6172,7 @@ function make6(shape, runtime, options) {
               kind: "source-refresh",
               name: fieldPath
             },
-            () => import_effect53.Effect.gen(function* () {
+            () => import_effect56.Effect.gen(function* () {
               const state = yield* runtime.getState;
               return yield* runHandler(state);
             })
@@ -5114,18 +6189,18 @@ function make6(shape, runtime, options) {
         if (isModuleLike(arg)) {
           const domain = arg;
           const tag = domain.tag;
-          const resolveAndBuild = resolveModuleRuntime(tag).pipe(import_effect53.Effect.map((rt) => buildModuleHandle(tag, rt)));
+          const resolveAndBuild = resolveModuleRuntime(tag).pipe(import_effect56.Effect.map((rt) => buildModuleHandle(tag, rt)));
           const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(
-            import_effect53.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
-            import_effect53.Effect.map((rt) => buildModuleHandle(tag, rt))
+            import_effect56.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
+            import_effect56.Effect.map((rt) => buildModuleHandle(tag, rt))
           );
-          const detectAndSelect = import_effect53.FiberRef.get(currentDiagnosticsLevel).pipe(
-            import_effect53.Effect.tap((level) => {
+          const detectAndSelect = import_effect56.FiberRef.get(currentDiagnosticsLevel).pipe(
+            import_effect56.Effect.tap((level) => {
               cachedDiagnosticsLevel = level;
             }),
-            import_effect53.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
+            import_effect56.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
           );
-          return import_effect53.Effect.suspend(() => {
+          return import_effect56.Effect.suspend(() => {
             if (cachedDiagnosticsLevel === "off") {
               return resolveAndBuild;
             }
@@ -5135,16 +6210,16 @@ function make6(shape, runtime, options) {
             return detectAndSelect;
           });
         }
-        if (import_effect53.Context.isTag(arg)) {
+        if (import_effect56.Context.isTag(arg)) {
           const candidate = arg;
           if (candidate._kind === "ModuleTag") {
             return resolveModuleRuntime(arg).pipe(
-              import_effect53.Effect.map((rt) => buildModuleHandle(arg, rt))
+              import_effect56.Effect.map((rt) => buildModuleHandle(arg, rt))
             );
           }
           return arg;
         }
-        return import_effect53.Effect.die("BoundApi.use: unsupported argument");
+        return import_effect56.Effect.die("BoundApi.use: unsupported argument");
       }
     }),
     onAction: new Proxy(() => {
@@ -5156,33 +6231,33 @@ function make6(shape, runtime, options) {
           const tag = arg.tag;
           return createIntentBuilder(
             runtime.actions$.pipe(
-              import_effect53.Stream.filter((a) => a._tag === tag || a.type === tag),
-              import_effect53.Stream.map((a) => a.payload)
+              import_effect56.Stream.filter((a) => a._tag === tag || a.type === tag),
+              import_effect56.Stream.map((a) => a.payload)
             ),
             tag
           );
         }
         if (typeof arg === "function") {
-          return createIntentBuilder(runtime.actions$.pipe(import_effect53.Stream.filter(arg)));
+          return createIntentBuilder(runtime.actions$.pipe(import_effect56.Stream.filter(arg)));
         }
         if (typeof arg === "string") {
           return createIntentBuilder(
-            runtime.actions$.pipe(import_effect53.Stream.filter((a) => a._tag === arg || a.type === arg)),
+            runtime.actions$.pipe(import_effect56.Stream.filter((a) => a._tag === arg || a.type === arg)),
             arg
           );
         }
         if (typeof arg === "object" && arg !== null) {
           if ("_tag" in arg) {
             return createIntentBuilder(
-              runtime.actions$.pipe(import_effect53.Stream.filter((a) => a._tag === arg._tag)),
+              runtime.actions$.pipe(import_effect56.Stream.filter((a) => a._tag === arg._tag)),
               String(arg._tag)
             );
           }
-          if (import_effect53.Schema.isSchema(arg)) {
+          if (import_effect56.Schema.isSchema(arg)) {
             return createIntentBuilder(
               runtime.actions$.pipe(
-                import_effect53.Stream.filter((a) => {
-                  const result = import_effect53.Schema.decodeUnknownSync(arg)(a);
+                import_effect56.Stream.filter((a) => {
+                  const result = import_effect56.Schema.decodeUnknownSync(arg)(a);
                   return !!result;
                 })
               )
@@ -5195,7 +6270,7 @@ function make6(shape, runtime, options) {
         guardRunOnly("use_in_setup", "$.onAction");
         if (typeof prop === "string") {
           return createIntentBuilder(
-            runtime.actions$.pipe(import_effect53.Stream.filter((a) => a._tag === prop || a.type === prop)),
+            runtime.actions$.pipe(import_effect56.Stream.filter((a) => a._tag === prop || a.type === prop)),
             prop
           );
         }
@@ -5216,7 +6291,7 @@ function make6(shape, runtime, options) {
 }
 
 // src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
-var import_effect54 = require("effect");
+var import_effect57 = require("effect");
 
 // src/internal/runtime/core/runner/ProgramRunner.errors.ts
 var summarizeCause = (cause) => {
@@ -5323,17 +6398,22 @@ var DisposeTimeoutError = class extends ProgramRunnerErrorBase {
 
 // src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
 var closeProgramScope = (params) => {
-  return import_effect54.Effect.gen(function* () {
+  return import_effect57.Effect.gen(function* () {
     const start = Date.now();
-    const fiber = yield* import_effect54.Effect.forkDaemon(import_effect54.Scope.close(params.scope, import_effect54.Exit.void));
+    const hostSchedulerOpt = yield* import_effect57.Effect.serviceOption(HostSchedulerTag);
+    const hostScheduler = import_effect57.Option.isSome(hostSchedulerOpt) ? hostSchedulerOpt.value : getGlobalHostScheduler();
+    const yieldMicrotask = import_effect57.Effect.async((resume) => {
+      hostScheduler.scheduleMicrotask(() => resume(import_effect57.Effect.void));
+    });
+    const fiber = yield* import_effect57.Effect.forkDaemon(import_effect57.Scope.close(params.scope, import_effect57.Exit.void));
     while (true) {
-      const exitOpt = yield* import_effect54.Fiber.poll(fiber);
-      if (import_effect54.Option.isSome(exitOpt)) {
+      const exitOpt = yield* import_effect57.Fiber.poll(fiber);
+      if (import_effect57.Option.isSome(exitOpt)) {
         const exit = exitOpt.value;
         if (exit._tag === "Success") {
           return;
         }
-        return yield* import_effect54.Effect.die(new DisposeError(params.identity, exit.cause));
+        return yield* import_effect57.Effect.die(new DisposeError(params.identity, exit.cause));
       }
       const elapsedMs = Date.now() - start;
       if (elapsedMs >= params.timeoutMs) {
@@ -5342,12 +6422,12 @@ var closeProgramScope = (params) => {
           elapsedMs
         });
         if (typeof params.onError === "function") {
-          yield* params.onError(import_effect54.Cause.die(error)).pipe(import_effect54.Effect.catchAllCause(() => import_effect54.Effect.void));
+          yield* params.onError(import_effect57.Cause.die(error)).pipe(import_effect57.Effect.catchAllCause(() => import_effect57.Effect.void));
         }
-        yield* import_effect54.Fiber.interruptFork(fiber);
-        return yield* import_effect54.Effect.die(error);
+        yield* import_effect57.Fiber.interruptFork(fiber);
+        return yield* import_effect57.Effect.die(error);
       }
-      yield* import_effect54.Effect.promise(() => new Promise((r) => queueMicrotask(r)));
+      yield* yieldMicrotask;
     }
   });
 };
@@ -5374,7 +6454,7 @@ var reportErrorIfEnabled = (enabled, error) => {
 };
 
 // src/internal/runtime/core/runner/ProgramRunner.signals.ts
-var import_effect55 = require("effect");
+var import_effect58 = require("effect");
 var getProcess2 = () => globalThis.process;
 var isNodeProcess = (value) => typeof value === "object" && value !== null && typeof value.on === "function";
 var removeListener = (proc, event, handler) => {
@@ -5388,24 +6468,24 @@ var removeListener = (proc, event, handler) => {
 };
 var installGracefulShutdownHandlers = (params) => {
   if (!params.enabled) {
-    return import_effect55.Effect.void;
+    return import_effect58.Effect.void;
   }
   const proc = getProcess2();
   if (!isNodeProcess(proc)) {
-    return import_effect55.Effect.void;
+    return import_effect58.Effect.void;
   }
   const handler = () => {
-    void import_effect55.Effect.runPromise(import_effect55.Scope.close(params.scope, import_effect55.Exit.void));
+    void import_effect58.Effect.runPromise(import_effect58.Scope.close(params.scope, import_effect58.Exit.void));
   };
-  return import_effect55.Effect.gen(function* () {
-    yield* import_effect55.Scope.addFinalizer(
+  return import_effect58.Effect.gen(function* () {
+    yield* import_effect58.Scope.addFinalizer(
       params.scope,
-      import_effect55.Effect.sync(() => {
+      import_effect58.Effect.sync(() => {
         removeListener(proc, "SIGINT", handler);
         removeListener(proc, "SIGTERM", handler);
       })
     );
-    yield* import_effect55.Effect.sync(() => {
+    yield* import_effect58.Effect.sync(() => {
       proc.on("SIGINT", handler);
       proc.on("SIGTERM", handler);
     });
@@ -5413,15 +6493,15 @@ var installGracefulShutdownHandlers = (params) => {
 };
 
 // src/internal/runtime/core/runner/ProgramRunner.kernel.ts
-var import_effect56 = require("effect");
-var makeProgramRunnerKernel = (makeRuntime, rootImpl, options) => import_effect56.Effect.gen(function* () {
+var import_effect59 = require("effect");
+var makeProgramRunnerKernel = (makeRuntime, rootImpl, options) => import_effect59.Effect.gen(function* () {
   const identity = {
     moduleId: String(rootImpl.module.id),
     instanceId: "unknown"
   };
-  const scope = yield* import_effect56.Scope.make();
+  const scope = yield* import_effect59.Scope.make();
   const runtime = makeRuntime(rootImpl, options);
-  yield* import_effect56.Scope.addFinalizer(scope, import_effect56.Effect.promise(() => runtime.dispose()).pipe(import_effect56.Effect.asVoid));
+  yield* import_effect59.Scope.addFinalizer(scope, import_effect59.Effect.promise(() => runtime.dispose()).pipe(import_effect59.Effect.asVoid));
   const setInstanceId = (value) => {
     identity.instanceId = typeof value === "string" && value.length > 0 ? value : String(value ?? "unknown");
   };
@@ -5468,23 +6548,23 @@ var resolveProgramRunnerOptions = (options) => {
 };
 
 // src/internal/runtime/core/runner/ProgramRunner.ts
-var openProgram = (makeRuntime, rootImpl, options) => import_effect57.Effect.gen(function* () {
-  const inTxn = yield* import_effect57.FiberRef.get(inSyncTransactionFiber);
+var openProgram = (makeRuntime, rootImpl, options) => import_effect60.Effect.gen(function* () {
+  const inTxn = yield* import_effect60.FiberRef.get(inSyncTransactionFiber);
   if (inTxn) {
-    return yield* import_effect57.Effect.dieMessage(
+    return yield* import_effect60.Effect.dieMessage(
       "[Logix] Runtime.openProgram/runProgram is not allowed inside a synchronous StateTransaction body"
     );
   }
   const runnerOptions = resolveProgramRunnerOptions(options);
   const kernel = yield* makeProgramRunnerKernel(makeRuntime, rootImpl, options);
-  yield* import_effect57.Effect.addFinalizer(
+  yield* import_effect60.Effect.addFinalizer(
     () => kernel.close({
       timeoutMs: runnerOptions.closeScopeTimeout,
       onError: options?.onError
     })
   );
   yield* kernel.installSignals(runnerOptions.handleSignals);
-  const moduleRuntime = yield* import_effect57.Effect.tryPromise({
+  const moduleRuntime = yield* import_effect60.Effect.tryPromise({
     try: () => kernel.runtime.runPromise(rootImpl.module),
     catch: (error) => new BootError(kernel.identity, error)
   });
@@ -5500,16 +6580,16 @@ var runProgram = async (makeRuntime, rootImpl, main, options) => {
     moduleId: String(rootImpl.module.id),
     instanceId: "unknown"
   };
-  const scope = import_effect57.Effect.runSync(import_effect57.Scope.make());
+  const scope = import_effect60.Effect.runSync(import_effect60.Scope.make());
   const runtime = makeRuntime(rootImpl, options);
   let ctx;
   let mainError;
   let closeError;
   let result;
   try {
-    import_effect57.Effect.runSync(import_effect57.Scope.addFinalizer(scope, import_effect57.Effect.promise(() => runtime.dispose()).pipe(import_effect57.Effect.asVoid)));
+    import_effect60.Effect.runSync(import_effect60.Scope.addFinalizer(scope, import_effect60.Effect.promise(() => runtime.dispose()).pipe(import_effect60.Effect.asVoid)));
     if (runnerOptions.handleSignals) {
-      import_effect57.Effect.runSync(
+      import_effect60.Effect.runSync(
         installGracefulShutdownHandlers({
           scope,
           enabled: true
@@ -5549,7 +6629,7 @@ var runProgram = async (makeRuntime, rootImpl, main, options) => {
       }
     }
   } finally {
-    const exit = await import_effect57.Effect.runPromiseExit(
+    const exit = await import_effect60.Effect.runPromiseExit(
       closeProgramScope({
         scope,
         timeoutMs: runnerOptions.closeScopeTimeout,
@@ -5558,16 +6638,16 @@ var runProgram = async (makeRuntime, rootImpl, main, options) => {
       })
     );
     if (exit._tag === "Failure") {
-      const failureOpt = import_effect57.Cause.failureOption(exit.cause);
-      if (import_effect57.Option.isSome(failureOpt)) {
+      const failureOpt = import_effect60.Cause.failureOption(exit.cause);
+      if (import_effect60.Option.isSome(failureOpt)) {
         const error = failureOpt.value;
         if (mainError !== void 0 && error && typeof error === "object") {
           error.mainError = mainError;
         }
         closeError = error;
       } else {
-        const defectOpt = import_effect57.Cause.dieOption(exit.cause);
-        if (import_effect57.Option.isSome(defectOpt) && defectOpt.value instanceof Error) {
+        const defectOpt = import_effect60.Cause.dieOption(exit.cause);
+        if (import_effect60.Option.isSome(defectOpt) && defectOpt.value instanceof Error) {
           const error = defectOpt.value;
           if (mainError !== void 0 && error && typeof error === "object") {
             error.mainError = mainError;
@@ -5600,9 +6680,9 @@ var make7 = (root, options) => {
   const rootImpl = resolveRootImpl(root);
   warnInvalidConcurrencyPolicyDevOnly(options?.concurrencyPolicy, "Runtime.make options.concurrencyPolicy");
   warnInvalidStateTransactionRuntimeConfigDevOnly(options?.stateTransaction, "Runtime.make options.stateTransaction");
-  const debugLayer = options?.debug === true ? layer2() : options?.debug ? layer2(options.debug) : import_effect58.Layer.empty;
-  const userLayer = options?.layer ?? import_effect58.Layer.empty;
-  const userWithDebug = options?.debug ? import_effect58.Layer.mergeAll(userLayer, debugLayer) : userLayer;
+  const debugLayer = options?.debug === true ? layer2() : options?.debug ? layer2(options.debug) : import_effect61.Layer.empty;
+  const userLayer = options?.layer ?? import_effect61.Layer.empty;
+  const userWithDebug = options?.debug ? import_effect61.Layer.mergeAll(userLayer, debugLayer) : userLayer;
   let middlewareStack = options?.middleware ?? [];
   const devtoolsOptions = options?.devtools === true ? {} : options?.devtools;
   if (options?.devtools) {
@@ -5612,16 +6692,16 @@ var make7 = (root, options) => {
       observer: observerConfig
     });
   }
-  const effectOpLayer = middlewareStack.length > 0 ? import_effect58.Layer.succeed(EffectOpMiddlewareTag, {
+  const effectOpLayer = middlewareStack.length > 0 ? import_effect61.Layer.succeed(EffectOpMiddlewareTag, {
     stack: middlewareStack
-  }) : import_effect58.Layer.empty;
-  const baseLayer = options?.label != null ? import_effect58.Layer.mergeAll(runtimeLabel(options.label), userWithDebug) : userWithDebug;
+  }) : import_effect61.Layer.empty;
+  const baseLayer = options?.label != null ? import_effect61.Layer.mergeAll(runtimeLabel(options.label), userWithDebug) : userWithDebug;
   const baseWithDevtools = options?.devtools ? devtoolsHubLayer(baseLayer, {
     bufferSize: devtoolsOptions?.bufferSize,
     diagnosticsLevel: devtoolsOptions?.diagnosticsLevel,
     traitConvergeDiagnosticsSampling: devtoolsOptions?.traitConvergeDiagnosticsSampling
   }) : baseLayer;
-  const appLayer = import_effect58.Layer.mergeAll(
+  const appLayer = import_effect61.Layer.mergeAll(
     runSessionLayer(),
     layer3(),
     baseWithDevtools,
@@ -5643,6 +6723,7 @@ var make7 = (root, options) => {
     modules: [provide(rootImpl.module, rootImpl.layer)],
     processes: rootImpl.processes ?? [],
     onError: options?.onError,
+    hostScheduler: options?.hostScheduler,
     stateTransaction: options?.stateTransaction,
     concurrencyPolicy: options?.concurrencyPolicy,
     readQueryStrictGate
@@ -5650,6 +6731,14 @@ var make7 = (root, options) => {
   const app = makeApp(appConfig);
   return app.makeRuntime();
 };
+var batch = (fn) => {
+  enterRuntimeBatch();
+  try {
+    return fn();
+  } finally {
+    exitRuntimeBatch();
+  }
+};
 var openProgram2 = (root, options) => openProgram(
   (rootImpl, runtimeOptions) => make7(rootImpl, runtimeOptions),
   resolveRootImpl(root),
@@ -5663,18 +6752,18 @@ var runProgram2 = async (root, main, options) => runProgram(
 );
 var stateTransactionOverridesLayer = (overrides) => {
   warnInvalidStateTransactionOverridesDevOnly(overrides, "Runtime.stateTransactionOverridesLayer");
-  return import_effect58.Layer.succeed(StateTransactionOverridesTag, overrides);
+  return import_effect61.Layer.succeed(StateTransactionOverridesTag, overrides);
 };
 var concurrencyPolicyOverridesLayer = (overrides) => {
   warnInvalidConcurrencyPolicyDevOnly(overrides, "Runtime.concurrencyPolicyOverridesLayer");
-  return import_effect58.Layer.succeed(ConcurrencyPolicyOverridesTag, overrides);
+  return import_effect61.Layer.succeed(ConcurrencyPolicyOverridesTag, overrides);
 };
 var setTraitConvergeOverride = (runtime, moduleId, overrides) => {
   warnInvalidStateTransactionTraitConvergeOverridesDevOnly(overrides, `Runtime.setTraitConvergeOverride(${moduleId})`);
   runtime.runSync(
-    import_effect58.Effect.gen(function* () {
-      const runtimeConfigOpt = yield* import_effect58.Effect.serviceOption(StateTransactionConfigTag);
-      if (import_effect58.Option.isNone(runtimeConfigOpt)) {
+    import_effect61.Effect.gen(function* () {
+      const runtimeConfigOpt = yield* import_effect61.Effect.serviceOption(StateTransactionConfigTag);
+      if (import_effect61.Option.isNone(runtimeConfigOpt)) {
         return;
       }
       const runtimeConfig = runtimeConfigOpt.value;
@@ -5693,9 +6782,9 @@ var setTraitConvergeOverride = (runtime, moduleId, overrides) => {
 var setConcurrencyPolicyOverride = (runtime, moduleId, patch) => {
   warnInvalidConcurrencyPolicyPatchDevOnly(patch, `Runtime.setConcurrencyPolicyOverride(${moduleId})`);
   runtime.runSync(
-    import_effect58.Effect.gen(function* () {
-      const runtimeConfigOpt = yield* import_effect58.Effect.serviceOption(ConcurrencyPolicyTag);
-      if (import_effect58.Option.isNone(runtimeConfigOpt)) {
+    import_effect61.Effect.gen(function* () {
+      const runtimeConfigOpt = yield* import_effect61.Effect.serviceOption(ConcurrencyPolicyTag);
+      if (import_effect61.Option.isNone(runtimeConfigOpt)) {
         return;
       }
       const runtimeConfig = runtimeConfigOpt.value;
@@ -5711,7 +6800,7 @@ var setConcurrencyPolicyOverride = (runtime, moduleId, patch) => {
     })
   );
 };
-var applyTransactionSnapshot = (moduleId, instanceId, txnId, mode) => import_effect58.Effect.gen(function* () {
+var applyTransactionSnapshot = (moduleId, instanceId, txnId, mode) => import_effect61.Effect.gen(function* () {
   const runtime = getRuntimeByModuleAndInstance(moduleId, instanceId);
   if (!runtime) {
     return;
@@ -5729,6 +6818,7 @@ var applyTransactionSnapshot = (moduleId, instanceId, txnId, mode) => import_eff
   DisposeTimeoutError,
   MainError,
   applyTransactionSnapshot,
+  batch,
   concurrencyPolicyOverridesLayer,
   make,
   openProgram,