@logixjs/core 0.0.1 → 1.0.0

package/dist/Bound.cjs

@@ -20,21 +20,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/Bound.ts
 var Bound_exports = {};
 __export(Bound_exports, {
-  make: () => make4
+  make: () => make5
 });
 module.exports = __toCommonJS(Bound_exports);
 
 // src/internal/runtime/core/BoundApiRuntime.ts
-var import_effect16 = require("effect");
+var import_effect20 = require("effect");
 
 // src/internal/action.ts
 var import_effect = require("effect");
 var isActionToken = (value) => typeof value === "function" && value._kind === "ActionToken" && typeof value.tag === "string" && import_effect.Schema.isSchema(value.schema);
 
 // src/internal/runtime/core/TaskRunner.ts
-var import_effect6 = require("effect");
+var import_effect10 = require("effect");
 
-// src/internal/runtime/core/DebugSink.ts
+// src/internal/runtime/core/DebugSink.record.ts
 var import_effect4 = require("effect");
 
 // src/internal/observability/jsonValue.ts
@@ -52,18 +52,27 @@ var import_effect2 = require("effect");
 
 // src/internal/runtime/core/EffectOpCore.ts
 var import_effect3 = require("effect");
-var currentLinkId = import_effect3.FiberRef.unsafeMake(void 0);
-var EffectOpMiddlewareTag = class extends import_effect3.Context.Tag("Logix/EffectOpMiddleware")() {
+var currentLinkId = import_effect3.ServiceMap.Reference("@logixjs/core/CurrentLinkId", {
+  defaultValue: () => void 0
+});
+var composeMiddlewareCache = /* @__PURE__ */ new WeakMap();
+var EffectOpMiddlewareTag = class extends import_effect3.ServiceMap.Service()("Logix/EffectOpMiddleware") {
 };
 var composeMiddleware = (stack) => {
-  return (op) => stack.reduceRight(
+  const cached = composeMiddlewareCache.get(stack);
+  if (cached) {
+    return cached;
+  }
+  const composed = (op) => stack.reduceRight(
     (eff, mw) => mw({ ...op, effect: eff }),
     op.effect
   );
+  composeMiddlewareCache.set(stack, composed);
+  return composed;
 };
 var runWithMiddleware = (op, stack) => {
   return import_effect3.Effect.gen(function* () {
-    const existing = yield* import_effect3.FiberRef.get(currentLinkId);
+    const existing = yield* import_effect3.Effect.service(currentLinkId);
     const metaLinkId = op.meta?.linkId;
     const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
     const nextOp = {
@@ -74,29 +83,51 @@ var runWithMiddleware = (op, stack) => {
       }
     };
     const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
-    return yield* import_effect3.Effect.locally(currentLinkId, linkId)(program);
+    return yield* import_effect3.Effect.provideService(program, currentLinkId, linkId);
   });
 };
 
-// src/internal/runtime/core/DebugSink.ts
-var currentDebugSinks = import_effect4.FiberRef.unsafeMake([]);
-var currentRuntimeLabel = import_effect4.FiberRef.unsafeMake(void 0);
-var currentTxnId = import_effect4.FiberRef.unsafeMake(void 0);
-var currentOpSeq = import_effect4.FiberRef.unsafeMake(void 0);
-var currentDiagnosticsLevel = import_effect4.FiberRef.unsafeMake("off");
-var currentTraitConvergeDiagnosticsSampling = import_effect4.FiberRef.unsafeMake({
-  sampleEveryN: 32,
-  topK: 3
+// src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = import_effect4.ServiceMap.Reference("@logixjs/core/Debug.currentDebugSinks", {
+  defaultValue: () => []
+});
+var currentRuntimeLabel = import_effect4.ServiceMap.Reference("@logixjs/core/Debug.currentRuntimeLabel", {
+  defaultValue: () => void 0
+});
+var currentTxnId = import_effect4.ServiceMap.Reference("@logixjs/core/Debug.currentTxnId", {
+  defaultValue: () => void 0
+});
+var currentOpSeq = import_effect4.ServiceMap.Reference("@logixjs/core/Debug.currentOpSeq", {
+  defaultValue: () => void 0
 });
+var currentDiagnosticsLevel = import_effect4.ServiceMap.Reference("@logixjs/core/Debug.currentDiagnosticsLevel", {
+  defaultValue: () => "off"
+});
+var currentDiagnosticsMaterialization = import_effect4.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentDiagnosticsMaterialization",
+  {
+    defaultValue: () => "eager"
+  }
+);
+var currentTraceMode = import_effect4.ServiceMap.Reference("@logixjs/core/Debug.currentTraceMode", {
+  defaultValue: () => "on"
+});
+var currentTraitConvergeDiagnosticsSampling = import_effect4.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentTraitConvergeDiagnosticsSampling",
+  {
+    defaultValue: () => ({
+      sampleEveryN: 32,
+      topK: 3
+    })
+  }
+);
 var browserLifecycleSeen = /* @__PURE__ */ new Set();
 var browserDiagnosticSeen = /* @__PURE__ */ new Set();
 var lifecycleErrorLog = (event) => {
   const moduleId = event.moduleId ?? "unknown";
   const causePretty = (() => {
     try {
-      return import_effect4.Cause.pretty(event.cause, {
-        renderErrorCause: true
-      });
+      return import_effect4.Cause.pretty(event.cause);
     } catch {
       try {
         return JSON.stringify(event.cause, null, 2);
@@ -137,16 +168,16 @@ ${detail}`;
   }
   return base.pipe(import_effect4.Effect.annotateLogs(annotations));
 };
-var noopLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, []);
+var noopLayer = import_effect4.Layer.succeed(currentDebugSinks, []);
 var errorOnlySink = {
   record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect4.Effect.void
 };
-var errorOnlyLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var errorOnlyLayer = import_effect4.Layer.succeed(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_effect4.Effect.logDebug({ debugEvent: event })
 };
-var consoleLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var consoleLayer = import_effect4.Layer.succeed(currentDebugSinks, [consoleSink]);
 var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
 var renderBrowserConsoleEvent = (event) => {
   if (typeof event.type === "string" && event.type.startsWith("trace:")) {
@@ -172,7 +203,7 @@ var renderBrowserConsoleEvent = (event) => {
     const moduleId = event.moduleId ?? "unknown";
     const causePretty = (() => {
       try {
-        return import_effect4.Cause.pretty(event.cause, { renderErrorCause: true });
+        return import_effect4.Cause.pretty(event.cause);
       } catch {
         try {
           return JSON.stringify(event.cause, null, 2);
@@ -238,7 +269,7 @@ var browserConsoleSink = {
     return renderBrowserConsoleEvent(event);
   }
 };
-var browserConsoleLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserConsoleLayer = import_effect4.Layer.succeed(currentDebugSinks, [browserConsoleSink]);
 var browserDiagnosticConsoleSink = {
   record: (event) => {
     if (!isBrowser) {
@@ -247,36 +278,33 @@ var browserDiagnosticConsoleSink = {
     return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect4.Effect.void;
   }
 };
-var browserDiagnosticConsoleLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
-var browserPrettyLoggerLayer = import_effect4.Logger.replace(
-  import_effect4.Logger.defaultLogger,
-  import_effect4.Logger.prettyLogger({ mode: "browser", colors: true })
+var browserDiagnosticConsoleLayer = import_effect4.Layer.succeed(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect4.Layer.effect(
+  import_effect4.Logger.CurrentLoggers,
+  import_effect4.Effect.gen(function* () {
+    const current = yield* import_effect4.Effect.service(import_effect4.Logger.CurrentLoggers);
+    return new Set(
+      [...current].filter((logger) => logger !== import_effect4.Logger.defaultLogger).concat(import_effect4.Logger.consolePretty({ mode: "browser", colors: true }))
+    );
+  })
 );
 var record = (event) => import_effect4.Effect.gen(function* () {
-  const sinks = yield* import_effect4.FiberRef.get(currentDebugSinks);
+  const sinks = yield* import_effect4.Effect.service(currentDebugSinks);
   if (isErrorOnlyOnlySinks(sinks)) {
     if (event.type === "lifecycle:error") {
       yield* lifecycleErrorLog(event);
       return;
     }
-    if (event.type === "diagnostic") {
-      if (event.severity !== "info") {
-        yield* diagnosticLog(event);
-      } else {
-        yield* import_effect4.Effect.void;
-      }
-      return;
+    if (event.type === "diagnostic" && event.severity !== "info") {
+      yield* diagnosticLog(event);
     }
-    yield* import_effect4.Effect.void;
     return;
   }
   if (sinks.length === 0) {
     if (isBrowser) {
       if (event.type === "lifecycle:error" || event.type === "diagnostic") {
         yield* renderBrowserConsoleEvent(event);
-        return;
       }
-      yield* import_effect4.Effect.void;
       return;
     }
     if (event.type === "lifecycle:error") {
@@ -285,13 +313,15 @@ var record = (event) => import_effect4.Effect.gen(function* () {
     }
     if (event.type === "diagnostic") {
       yield* diagnosticLog(event);
-      return;
     }
-    yield* import_effect4.Effect.void;
     return;
   }
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const mode = yield* import_effect4.Effect.service(currentTraceMode);
+    if (mode === "off") return;
+  }
   const enriched = event;
-  const diagnosticsLevel = yield* import_effect4.FiberRef.get(currentDiagnosticsLevel);
+  const diagnosticsLevel = yield* import_effect4.Effect.service(currentDiagnosticsLevel);
   let now;
   const getNow = () => {
     if (now === void 0) now = Date.now();
@@ -302,24 +332,24 @@ var record = (event) => import_effect4.Effect.gen(function* () {
     enriched.timestamp = getNow();
   }
   if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
-    const runtimeLabel = yield* import_effect4.FiberRef.get(currentRuntimeLabel);
+    const runtimeLabel = yield* import_effect4.Effect.service(currentRuntimeLabel);
     if (runtimeLabel) {
       ;
       enriched.runtimeLabel = runtimeLabel;
     }
   }
   if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
-    const txnId = yield* import_effect4.FiberRef.get(currentTxnId);
+    const txnId = yield* import_effect4.Effect.service(currentTxnId);
     if (txnId) {
       ;
       enriched.txnId = txnId;
     }
   }
   if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
-    const linkId = yield* import_effect4.FiberRef.get(currentLinkId);
-    if (linkId) {
+    const maybeLinkId = yield* import_effect4.Effect.serviceOption(currentLinkId);
+    if (import_effect4.Option.isSome(maybeLinkId) && maybeLinkId.value) {
       ;
-      enriched.linkId = linkId;
+      enriched.linkId = maybeLinkId.value;
     }
   }
   if (sinks.length === 1) {
@@ -330,7 +360,508 @@ var record = (event) => import_effect4.Effect.gen(function* () {
 });
 
 // src/internal/runtime/core/env.ts
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/HostScheduler.ts
+var noopCancel = () => {
+};
+var safeNowMs = () => {
+  const perf = globalThis.performance;
+  if (perf && typeof perf.now === "function") {
+    try {
+      const v = perf.now();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+    } catch {
+    }
+  }
+  return Date.now();
+};
+var safeQueueMicrotask = (cb) => {
+  const qm = globalThis.queueMicrotask;
+  if (typeof qm === "function") {
+    try {
+      qm(cb);
+      return;
+    } catch {
+    }
+  }
+  try {
+    Promise.resolve().then(cb);
+  } catch {
+    setTimeout(cb, 0);
+  }
+};
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
+};
+var makeMessageChannelMacrotask = () => {
+  const MC = globalThis.MessageChannel;
+  if (typeof MC !== "function") return void 0;
+  let channel;
+  try {
+    channel = new MC();
+  } catch {
+    return void 0;
+  }
+  const queue = [];
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    const tasks = queue.splice(0, queue.length);
+    for (const t of tasks) {
+      if (t.canceled) continue;
+      try {
+        t.cb();
+      } catch {
+      }
+    }
+  };
+  try {
+    channel.port1.onmessage = flush;
+  } catch {
+    return void 0;
+  }
+  const schedule = (cb) => {
+    const task = { canceled: false, cb };
+    queue.push(task);
+    if (!scheduled) {
+      scheduled = true;
+      try {
+        channel.port2.postMessage(void 0);
+      } catch {
+        scheduled = false;
+        return safeSetTimeout(0, cb);
+      }
+    }
+    return () => {
+      task.canceled = true;
+    };
+  };
+  return schedule;
+};
+var makeSetImmediateMacrotask = () => {
+  const si = globalThis.setImmediate;
+  const ci = globalThis.clearImmediate;
+  if (typeof si !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = si(cb);
+    } catch {
+      return safeSetTimeout(0, cb);
+    }
+    return () => {
+      if (typeof ci !== "function") return;
+      try {
+        ci(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeRaf = () => {
+  const raf = globalThis.requestAnimationFrame;
+  const cancel = globalThis.cancelAnimationFrame;
+  if (typeof raf !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = raf(cb);
+    } catch {
+      return noopCancel;
+    }
+    return () => {
+      if (typeof cancel !== "function") return;
+      try {
+        cancel(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeDefaultHostScheduler = () => {
+  const macrotask = makeSetImmediateMacrotask() ?? makeMessageChannelMacrotask() ?? ((cb) => safeSetTimeout(0, cb));
+  const raf = makeRaf();
+  return {
+    nowMs: safeNowMs,
+    scheduleMicrotask: safeQueueMicrotask,
+    scheduleMacrotask: macrotask,
+    scheduleAnimationFrame: (cb) => raf?.(cb) ?? macrotask(cb),
+    scheduleTimeout: safeSetTimeout
+  };
+};
+var globalHostScheduler;
+var getGlobalHostScheduler = () => {
+  globalHostScheduler ?? (globalHostScheduler = makeDefaultHostScheduler());
+  return globalHostScheduler;
+};
+
+// src/internal/runtime/core/RuntimeStore.ts
+var parseTopicKey = (topicKey) => {
+  const idx = topicKey.indexOf("::");
+  if (idx <= 0) return void 0;
+  const moduleId = topicKey.slice(0, idx);
+  const rest = topicKey.slice(idx + 2);
+  if (rest.length === 0) return void 0;
+  const idx2 = rest.indexOf("::");
+  if (idx2 < 0) {
+    return { kind: "module", moduleInstanceKey: `${moduleId}::${rest}` };
+  }
+  const instanceId = rest.slice(0, idx2);
+  const suffix = rest.slice(idx2 + 2);
+  if (suffix.startsWith("rq:")) {
+    const selectorId = suffix.slice("rq:".length);
+    if (selectorId.length === 0) return void 0;
+    return {
+      kind: "readQuery",
+      moduleInstanceKey: `${moduleId}::${instanceId}`,
+      selectorId
+    };
+  }
+  return { kind: "module", moduleInstanceKey: `${moduleId}::${instanceId}` };
+};
+var EMPTY_LISTENER_SNAPSHOT = [];
+var NO_CHANGED_TOPIC_LISTENERS = [];
+var makeRuntimeStore = () => {
+  let tickSeq = 0;
+  const moduleStates = /* @__PURE__ */ new Map();
+  const topicVersions = /* @__PURE__ */ new Map();
+  const topicPriorities = /* @__PURE__ */ new Map();
+  const listenersByTopic = /* @__PURE__ */ new Map();
+  const subscriberCountByModule = /* @__PURE__ */ new Map();
+  const getTopicVersion = (topicKey) => topicVersions.get(topicKey) ?? 0;
+  const getTopicPriority = (topicKey) => topicPriorities.get(topicKey) ?? "normal";
+  const commitTopicBump = (topicKey, priority) => {
+    const prev = topicVersions.get(topicKey) ?? 0;
+    topicVersions.set(topicKey, prev + 1);
+    topicPriorities.set(topicKey, priority);
+  };
+  const refreshTopicSnapshot = (state) => {
+    state.snapshot = Array.from(state.listeners);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const state = existing ?? { listeners: /* @__PURE__ */ new Set(), snapshot: EMPTY_LISTENER_SNAPSHOT };
+    const alreadyHas = state.listeners.has(listener);
+    if (!alreadyHas) {
+      state.listeners.add(listener);
+      refreshTopicSnapshot(state);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, state);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const currentState = listenersByTopic.get(topicKey);
+      if (!currentState) return;
+      const deleted = currentState.listeners.delete(listener);
+      if (deleted && info) {
+        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          subscriberCountByModule.delete(info.moduleInstanceKey);
+        } else {
+          subscriberCountByModule.set(info.moduleInstanceKey, next);
+        }
+      }
+      if (currentState.listeners.size === 0) {
+        listenersByTopic.delete(topicKey);
+      } else if (deleted) {
+        refreshTopicSnapshot(currentState);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.listeners.size ?? 0;
+  const getModuleSubscriberCount = (moduleInstanceKey) => subscriberCountByModule.get(moduleInstanceKey) ?? 0;
+  const registerModuleInstance = (args) => {
+    moduleStates.set(args.moduleInstanceKey, args.initialState);
+    if (!topicVersions.has(args.moduleInstanceKey)) {
+      topicVersions.set(args.moduleInstanceKey, 0);
+      topicPriorities.set(args.moduleInstanceKey, "normal");
+    }
+  };
+  const unregisterModuleInstance = (moduleInstanceKey) => {
+    moduleStates.delete(moduleInstanceKey);
+  };
+  const commitTick = (args) => {
+    tickSeq = args.tickSeq;
+    for (const [key, commit] of args.accepted.modules) {
+      moduleStates.set(key, commit.state);
+    }
+    if (args.accepted.dirtyTopics.size === 0) {
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    if (args.onListener) {
+      let firstTopicListeners;
+      let secondTopicListeners;
+      let restTopicListeners;
+      for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+        commitTopicBump(topicKey, priority);
+        const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+        if (listeners.length === 0) {
+          continue;
+        }
+        if (!firstTopicListeners) {
+          firstTopicListeners = listeners;
+          continue;
+        }
+        if (!secondTopicListeners) {
+          secondTopicListeners = listeners;
+          continue;
+        }
+        if (!restTopicListeners) {
+          restTopicListeners = [];
+        }
+        restTopicListeners.push(listeners);
+      }
+      if (firstTopicListeners) {
+        for (const listener of firstTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (secondTopicListeners) {
+        for (const listener of secondTopicListeners) {
+          try {
+            args.onListener(listener);
+          } catch {
+          }
+        }
+      }
+      if (restTopicListeners) {
+        for (const listeners of restTopicListeners) {
+          for (const listener of listeners) {
+            try {
+              args.onListener(listener);
+            } catch {
+            }
+          }
+        }
+      }
+      return {
+        changedTopicListeners: NO_CHANGED_TOPIC_LISTENERS
+      };
+    }
+    let singleTopicListeners;
+    let flattenedTopicListeners;
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners = listenersByTopic.get(topicKey)?.snapshot ?? EMPTY_LISTENER_SNAPSHOT;
+      if (listeners.length === 0) {
+        continue;
+      }
+      if (flattenedTopicListeners) {
+        for (const listener of listeners) {
+          flattenedTopicListeners.push(listener);
+        }
+        continue;
+      }
+      if (!singleTopicListeners) {
+        singleTopicListeners = listeners;
+        continue;
+      }
+      flattenedTopicListeners = Array.from(singleTopicListeners);
+      for (const listener of listeners) {
+        flattenedTopicListeners.push(listener);
+      }
+    }
+    return {
+      changedTopicListeners: flattenedTopicListeners ?? singleTopicListeners ?? NO_CHANGED_TOPIC_LISTENERS
+    };
+  };
+  const getModuleState = (moduleInstanceKey) => moduleStates.get(moduleInstanceKey);
+  const dispose = () => {
+    moduleStates.clear();
+    topicVersions.clear();
+    topicPriorities.clear();
+    listenersByTopic.clear();
+    subscriberCountByModule.clear();
+  };
+  return {
+    getTickSeq: () => tickSeq,
+    getModuleState,
+    getTopicVersion,
+    getTopicPriority,
+    subscribeTopic,
+    getTopicSubscriberCount,
+    getModuleSubscriberCount,
+    registerModuleInstance,
+    unregisterModuleInstance,
+    commitTick,
+    dispose
+  };
+};
+
+// src/internal/runtime/core/TickScheduler.ts
 var import_effect5 = require("effect");
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect6 = 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_effect6.Effect.gen(function* () {
+    let scheduled = false;
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const ids = moduleAsSourceIdsBySource.get(sourceKey);
+      if (!ids || ids.size === 0) continue;
+      const commit = args.acceptedModules.get(sourceKey);
+      if (!commit) continue;
+      for (const id of ids) {
+        const link = moduleAsSourceById.get(id);
+        if (!link) continue;
+        let selected;
+        try {
+          selected = link.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const nextValue = link.computeValue(selected);
+        if (link.hasValue && link.equalsValue(link.lastValue, nextValue)) {
+          continue;
+        }
+        link.hasValue = true;
+        link.lastValue = nextValue;
+        scheduled = true;
+        yield* link.applyValue(nextValue);
+      }
+    }
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const refs = declarativeReadNodesBySource.get(sourceKey);
+      if (!refs || refs.length === 0) continue;
+      const commit = args.acceptedModules.get(sourceKey);
+      if (!commit) continue;
+      for (const ref of refs) {
+        const link = declarativeById.get(ref.linkId);
+        if (!link) continue;
+        const readNode = link.readNodeById.get(ref.nodeId);
+        if (!readNode) continue;
+        let value;
+        try {
+          value = readNode.readQuery.select(commit.state);
+        } catch {
+          continue;
+        }
+        const state = link.readNodeState.get(ref.nodeId) ?? { hasValue: false, lastValue: void 0 };
+        const changed = !state.hasValue || !Object.is(state.lastValue, value);
+        if (!changed) continue;
+        state.hasValue = true;
+        state.lastValue = value;
+        link.readNodeState.set(ref.nodeId, state);
+        const targets = link.dispatchTargetsByReadNode.get(ref.nodeId) ?? [];
+        for (const dispatchNodeId of targets) {
+          const node = link.dispatchNodeById.get(dispatchNodeId);
+          if (!node) continue;
+          scheduled = true;
+          yield* node.dispatch(value);
+        }
+      }
+    }
+    return { scheduled };
+  });
+  return {
+    registerModuleAsSourceLink,
+    registerDeclarativeLink,
+    applyForSources
+  };
+};
+
+// src/internal/runtime/core/env.ts
 var getNodeEnv = () => {
   try {
     const env = globalThis?.process?.env;
@@ -340,22 +871,174 @@ var getNodeEnv = () => {
   }
 };
 var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+var StateTransactionConfigTagImpl = class extends import_effect7.ServiceMap.Service()("@logixjs/core/StateTransactionRuntimeConfig") {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect7.ServiceMap.Service()("@logixjs/core/ReadQueryStrictGateRuntimeConfig") {
 };
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var ReplayModeConfigTagImpl = class extends import_effect7.ServiceMap.Service()("@logixjs/core/ReplayModeConfig") {
 };
-var ReplayModeConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var StateTransactionOverridesTagImpl = class extends import_effect7.ServiceMap.Service()("@logixjs/core/StateTransactionOverrides") {
 };
-var StateTransactionOverridesTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var SchedulingPolicySurfaceTagImpl = class extends import_effect7.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurface") {
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var SchedulingPolicySurfaceOverridesTagImpl = class extends import_effect7.ServiceMap.Service()("@logixjs/core/SchedulingPolicySurfaceOverrides") {
 };
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var RuntimeStoreTag = class extends import_effect7.ServiceMap.Service()("@logixjs/core/RuntimeStore") {
+};
+var runtimeStoreLayer = import_effect7.Layer.effect(
+  RuntimeStoreTag,
+  import_effect7.Effect.acquireRelease(
+    import_effect7.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect7.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect7.ServiceMap.Service()("@logixjs/core/HostScheduler") {
+};
+var hostSchedulerLayer = import_effect7.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect7.ServiceMap.Service()("@logixjs/core/DeclarativeLinkRuntime") {
+};
+var declarativeLinkRuntimeLayer = import_effect7.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect7.ServiceMap.Service()("@logixjs/core/TickScheduler") {
+};
+
+// src/internal/runtime/core/ModeRunner.ts
+var import_effect9 = require("effect");
+
+// src/internal/runtime/core/LatestFiberSlot.ts
+var import_effect8 = require("effect");
+var make = () => import_effect8.Ref.make({
+  fiber: void 0,
+  runningId: 0,
+  nextId: 0
+});
+var beginRun = (slotRef) => import_effect8.Ref.modify(slotRef, (state) => {
+  const runId = state.nextId + 1;
+  const prevFiber = state.fiber;
+  const prevRunningId = state.runningId;
+  state.nextId = runId;
+  state.runningId = runId;
+  return [[prevFiber, prevRunningId, runId], state];
+});
+var setFiberIfCurrent = (slotRef, runId, fiber) => import_effect8.Ref.update(slotRef, (state) => {
+  if (state.runningId === runId) {
+    state.fiber = fiber;
+  }
+  return state;
+});
+var clearIfCurrent = (slotRef, runId) => import_effect8.Ref.update(slotRef, (state) => {
+  if (state.runningId === runId) {
+    state.runningId = 0;
+    state.fiber = void 0;
+  }
+  return state;
+});
+
+// src/internal/runtime/core/ModeRunner.ts
+var EXHAUST_ACQUIRE_BUSY = [true, true];
+var EXHAUST_REJECT_BUSY = [false, true];
+var beginSwitchLatestRun = (stateRef) => import_effect9.Ref.modify(stateRef, (state) => {
+  const runId = state.nextId + 1;
+  state.nextId = runId;
+  state.runningId = runId;
+  return [runId, state];
+});
+var clearSwitchLatestIfCurrent = (stateRef, runId) => import_effect9.Ref.update(stateRef, (state) => {
+  if (state.runningId === runId) {
+    state.runningId = 0;
+  }
+  return state;
+});
+var runLatestSwitch = (stream, runLatest) => import_effect9.Effect.gen(function* () {
+  const stateRef = yield* import_effect9.Ref.make({
+    runningId: 0,
+    nextId: 0
+  });
+  const makeEffect = (payload) => import_effect9.Effect.gen(function* () {
+    const runId = yield* beginSwitchLatestRun(stateRef);
+    const isCurrent = import_effect9.Ref.get(stateRef).pipe(import_effect9.Effect.map((state) => state.runningId === runId));
+    yield* runLatest(payload, { runId, isCurrent }).pipe(import_effect9.Effect.ensuring(clearSwitchLatestIfCurrent(stateRef, runId)));
+  });
+  return yield* import_effect9.Stream.runDrain(
+    import_effect9.Stream.map(stream, makeEffect).pipe(import_effect9.Stream.switchMap((effect) => import_effect9.Stream.fromEffect(effect)))
+  );
+});
+var runLatestFiberSlot = (stream, runLatest, awaitLatestOnEnd) => import_effect9.Effect.gen(function* () {
+  const stateRef = yield* make();
+  const start = (payload) => import_effect9.Effect.gen(function* () {
+    const [prevFiber, prevRunningId, runId] = yield* beginRun(stateRef);
+    if (prevFiber && prevRunningId !== 0) {
+      yield* import_effect9.Fiber.interrupt(prevFiber);
+    }
+    const isCurrent = import_effect9.Ref.get(stateRef).pipe(import_effect9.Effect.map((state) => state.runningId === runId));
+    const fiber = yield* import_effect9.Effect.forkChild(
+      runLatest(payload, { runId, isCurrent }).pipe(import_effect9.Effect.ensuring(clearIfCurrent(stateRef, runId)))
+    );
+    yield* setFiberIfCurrent(stateRef, runId, fiber);
+  });
+  yield* import_effect9.Stream.runForEach(stream, start);
+  if (!awaitLatestOnEnd) {
+    return;
+  }
+  const finalState = yield* import_effect9.Ref.get(stateRef);
+  const finalFiber = finalState.runningId !== 0 ? finalState.fiber : void 0;
+  if (finalFiber) {
+    yield* import_effect9.Fiber.join(finalFiber);
+  }
+});
+var runExhaust = (stream, run2, resolveConcurrencyLimit2) => import_effect9.Effect.gen(function* () {
+  const concurrency = yield* resolveConcurrencyLimit2;
+  const busyRef = yield* import_effect9.Ref.make(false);
+  const mapper = (payload) => import_effect9.Effect.gen(function* () {
+    const acquired = yield* import_effect9.Ref.modify(
+      busyRef,
+      (busy) => busy ? EXHAUST_REJECT_BUSY : EXHAUST_ACQUIRE_BUSY
+    );
+    if (!acquired) {
+      return;
+    }
+    try {
+      yield* run2(payload);
+    } finally {
+      yield* import_effect9.Ref.set(busyRef, false);
+    }
+  });
+  return yield* import_effect9.Stream.runDrain(stream.pipe(import_effect9.Stream.mapEffect(mapper, { concurrency })));
+});
+var runParallel = (stream, run2, resolveConcurrencyLimit2) => import_effect9.Effect.gen(function* () {
+  const concurrency = yield* resolveConcurrencyLimit2;
+  return yield* import_effect9.Stream.runDrain(stream.pipe(import_effect9.Stream.mapEffect(run2, { concurrency })));
+});
+var runByMode = (config) => {
+  const runLatest = config.runLatest ?? ((payload) => config.run(payload));
+  if (config.mode === "latest") {
+    const strategy = config.latest?.strategy ?? "switch";
+    if (strategy === "fiber-slot") {
+      return runLatestFiberSlot(config.stream, runLatest, config.latest?.awaitLatestOnEnd ?? false);
+    }
+    return runLatestSwitch(config.stream, runLatest);
+  }
+  if (config.mode === "exhaust") {
+    return runExhaust(config.stream, config.run, config.resolveConcurrencyLimit);
+  }
+  if (config.mode === "parallel") {
+    return runParallel(config.stream, config.run, config.resolveConcurrencyLimit);
+  }
+  return import_effect9.Stream.runForEach(config.stream, config.run);
 };
 
 // src/internal/runtime/core/TaskRunner.ts
-var inSyncTransactionFiber = import_effect6.FiberRef.unsafeMake(false);
-var forceSourceRefresh = import_effect6.FiberRef.unsafeMake(false);
+var inSyncTransactionFiber = import_effect10.ServiceMap.Reference("@logixjs/core/TaskRunner.inSyncTransactionFiber", {
+  defaultValue: () => false
+});
+var forceSourceRefresh = import_effect10.ServiceMap.Reference("@logixjs/core/TaskRunner.forceSourceRefresh", {
+  defaultValue: () => false
+});
 var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
 var defaultOrigins = (triggerName) => ({
   pending: {
@@ -371,8 +1054,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_effect10.Effect.gen(function* () {
+  const inTxn = yield* import_effect10.Effect.service(inSyncTransactionFiber);
   if (!inTxn) {
     return false;
   }
@@ -391,8 +1074,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_effect10.Effect.map((p) => p.concurrencyLimit)) : import_effect10.Effect.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_effect10.Effect.gen(function* () {
   const noop = yield* shouldNoopInSyncTransactionFiber({
     moduleId: runtime.moduleId,
     instanceId: runtime.instanceId,
@@ -413,12 +1096,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_effect10.Effect.uninterruptible(
+      runtime.runWithStateTransaction(origins.pending, () => import_effect10.Effect.asVoid(resolve(pending, payload)))
     );
   }
   const io = resolve(config.effect, payload);
-  const exit = yield* import_effect6.Effect.exit(io);
+  const exit = yield* import_effect10.Effect.exit(io);
   if (getCanWriteBack) {
     const ok = yield* getCanWriteBack;
     if (!ok) {
@@ -428,96 +1111,59 @@ 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_effect10.Effect.asVoid(success(exit.value, payload)));
     }
     return;
   }
   const cause = exit.cause;
-  if (import_effect6.Cause.isInterrupted(cause)) {
+  if (import_effect10.Cause.hasInterruptsOnly(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_effect10.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(
-    (cause) => record({
-      type: "diagnostic",
-      moduleId: runtime.moduleId,
-      instanceId: runtime.instanceId,
-      code: "task_runner::unhandled_failure",
-      severity: "error",
-      message: "TaskRunner encountered an unhandled failure (pending/IO/writeback).",
-      hint: "Add a failure writeback for this task or handle errors explicitly upstream; avoid fire-and-forget swallowing errors.",
-      actionTag: config.triggerName,
-      kind: "task_runner_unhandled_failure",
-      trigger: {
-        kind: "task",
-        name: config.triggerName
-      }
-    }).pipe(import_effect6.Effect.zipRight(import_effect6.Effect.logError("TaskRunner error", cause)))
-  )
+  import_effect10.Effect.catchCause((cause) => record({
+    type: "diagnostic",
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "task_runner::unhandled_failure",
+    severity: "error",
+    message: "TaskRunner encountered an unhandled failure (pending/IO/writeback).",
+    hint: "Add a failure writeback for this task or handle errors explicitly upstream; avoid fire-and-forget swallowing errors.",
+    actionTag: config.triggerName,
+    kind: "task_runner_unhandled_failure",
+    trigger: {
+      kind: "task",
+      name: config.triggerName
+    }
+  }).pipe(import_effect10.Effect.flatMap(() => import_effect10.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);
-        if (prev) {
-          yield* import_effect6.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(
-          runTaskLifecycle(payload, runtime, config, canWriteBack)
-        );
-        yield* import_effect6.Ref.set(currentFiberRef, fiber);
-      });
-      return yield* import_effect6.Stream.runForEach(stream, start);
-    });
-  }
-  if (mode === "exhaust") {
-    return import_effect6.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(
-          busyRef,
-          (busy) => busy ? [false, busy] : [true, true]
-        );
-        if (!acquired) {
-          return;
-        }
-        try {
-          yield* runTaskLifecycle(payload, runtime, config);
-        } finally {
-          yield* import_effect6.Ref.set(busyRef, false);
-        }
-      });
-      return yield* import_effect6.Stream.runDrain(stream.pipe(import_effect6.Stream.mapEffect(mapper, { concurrency })));
-    });
-  }
-  if (mode === "parallel") {
-    return import_effect6.Effect.gen(function* () {
-      const concurrency = yield* resolveConcurrencyLimit(runtime);
-      return yield* import_effect6.Stream.runDrain(
-        stream.pipe(
-          import_effect6.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
-            concurrency
-          })
-        )
-      );
-    });
-  }
-  return import_effect6.Stream.runForEach(
-    stream,
-    (payload) => runTaskLifecycle(payload, runtime, config)
-  );
+var runTask = (args) => {
+  const mode = args.mode ?? "task";
+  const runtime = args.runtime;
+  const config = args.config;
+  return runByMode({
+    stream: args.stream,
+    mode,
+    run: (payload) => runTaskLifecycle(payload, runtime, config),
+    runLatest: (payload, context) => runTaskLifecycle(payload, runtime, config, context.isCurrent),
+    resolveConcurrencyLimit: resolveConcurrencyLimit(runtime),
+    latest: {
+      strategy: "fiber-slot",
+      // Keep TaskRunner behavior: triggers are acknowledged once started; no need to await final IO on stream completion.
+      awaitLatestOnEnd: false
+    }
+  });
 };
+var makeTaskRunner = (stream, mode, runtime, config) => runTask({
+  stream,
+  mode,
+  runtime,
+  config
+});
 
 // src/internal/runtime/core/mutativePatches.ts
 var import_mutative = require("mutative");
@@ -530,23 +1176,59 @@ var isFieldPathSegment = (seg) => {
   if (seg.includes("[") || seg.includes("]")) return false;
   return true;
 };
+var toKey = (path) => {
+  let key = "";
+  for (let i = 0; i < path.length; i++) {
+    if (i > 0) key += "|";
+    const seg = path[i];
+    key += seg.length;
+    key += ":";
+    key += seg;
+  }
+  return key;
+};
 
 // src/internal/runtime/core/mutativePatches.ts
+var isNonNegativeIntString = (text) => {
+  if (!text) return false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  return true;
+};
 var toPatchFieldPath = (path) => {
   if (typeof path === "string") {
     const trimmed = path.trim();
     return trimmed.length > 0 ? "*" : void 0;
   }
   if (!Array.isArray(path)) return void 0;
+  let allValidString = true;
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i];
+    if (typeof seg !== "string" || !(isFieldPathSegment(seg) || isNonNegativeIntString(seg))) {
+      allValidString = false;
+      break;
+    }
+  }
+  if (allValidString) return path;
   const parts = [];
-  for (const seg of path) {
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i];
     if (typeof seg === "string") {
-      if (isFieldPathSegment(seg)) parts.push(seg);
+      if (isFieldPathSegment(seg) || isNonNegativeIntString(seg)) {
+        parts.push(seg);
+      }
       continue;
     }
+    if (typeof seg === "number" && Number.isFinite(seg)) {
+      const n = Math.floor(seg);
+      if (n >= 0 && n <= 2147483647) {
+        parts.push(String(n));
+      }
+    }
   }
-  if (parts.length === 0) return "*";
-  return parts;
+  return parts.length === 0 ? "*" : parts;
 };
 var mutateWithPatchPaths = (base, mutator) => {
   const out = (0, import_mutative.create)(base, mutator, {
@@ -560,28 +1242,65 @@ var mutateWithPatchPaths = (base, mutator) => {
   }
   const nextState = out[0];
   const patches = out[1] ?? [];
-  const dedup = /* @__PURE__ */ new Map();
-  for (const patch of patches) {
+  if (patches.length > 256) {
+    let sawStar2 = false;
+    const patchPaths2 = [];
+    for (let i = 0; i < patches.length; i++) {
+      const patch = patches[i];
+      const p = toPatchFieldPath(patch?.path);
+      if (!p) continue;
+      if (p === "*") {
+        if (sawStar2) continue;
+        sawStar2 = true;
+      }
+      patchPaths2.push(p);
+    }
+    return {
+      nextState,
+      patchPaths: patchPaths2
+    };
+  }
+  let sawStar = false;
+  const singleSeg = /* @__PURE__ */ new Set();
+  const multiSeg = /* @__PURE__ */ new Set();
+  const patchPaths = [];
+  for (let i = 0; i < patches.length; i++) {
+    const patch = patches[i];
     const p = toPatchFieldPath(patch?.path);
     if (!p) continue;
-    const key = p === "*" ? "*" : JSON.stringify(p);
-    if (!dedup.has(key)) dedup.set(key, p);
+    if (p === "*") {
+      if (sawStar) continue;
+      sawStar = true;
+      patchPaths.push(p);
+      continue;
+    }
+    if (p.length === 1) {
+      const seg = p[0];
+      if (singleSeg.has(seg)) continue;
+      singleSeg.add(seg);
+      patchPaths.push(p);
+      continue;
+    }
+    const key = toKey(p);
+    if (multiSeg.has(key)) continue;
+    multiSeg.add(key);
+    patchPaths.push(p);
   }
   return {
     nextState,
-    patchPaths: Array.from(dedup.values())
+    patchPaths
   };
 };
 
 // src/internal/runtime/core/FlowRuntime.ts
-var import_effect9 = require("effect");
+var import_effect13 = require("effect");
 
 // src/internal/effect-op.ts
-var import_effect8 = require("effect");
+var import_effect12 = require("effect");
 
 // src/internal/observability/runSession.ts
-var import_effect7 = require("effect");
-var RunSessionTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/RunSession")() {
+var import_effect11 = require("effect");
+var RunSessionTagImpl = class extends import_effect11.ServiceMap.Service()("@logixjs/core/RunSession") {
 };
 var RunSessionTag = RunSessionTagImpl;
 
@@ -592,7 +1311,7 @@ var nextOpSeq = () => {
   return nextGlobalOpSeq;
 };
 var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
-var make = (params) => ({
+var make2 = (params) => ({
   ...params.id ? { id: params.id, meta: params.meta } : (() => {
     const meta = params.meta ?? {};
     const instanceId = meta.instanceId;
@@ -609,16 +1328,383 @@ var make = (params) => ({
 });
 var run = (op, stack) => runWithMiddleware(op, stack);
 
+// src/internal/digest.ts
+var stableStringify = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const record2 = value;
+    const keys = Object.keys(record2).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record2[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
+
 // src/internal/runtime/core/ReadQuery.ts
 function isReadQuery(input) {
   if (!input || typeof input !== "object" && typeof input !== "function") return false;
   const maybe = input;
   return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads);
 }
+var normalizeReads = (reads) => {
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of reads) {
+    const key = typeof r === "number" ? `n:${r}` : `s:${r}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(r);
+  }
+  return unique.slice().sort();
+};
+var toHash32Number = (hex) => Number.parseInt(hex, 16);
+var makeReadsDigest = (reads) => {
+  const normalized = normalizeReads(reads);
+  return {
+    count: normalized.length,
+    hash: toHash32Number(fnv1a32(stableStringify(normalized)))
+  };
+};
+var computeSelectorId = (value) => `rq_${fnv1a32(stableStringify(value))}`;
+var nextUnstableSelectorSeq = 0;
+var unstableSelectorIdByFn = /* @__PURE__ */ new WeakMap();
+var computeUnstableSelectorId = (selector) => {
+  const existing = unstableSelectorIdByFn.get(selector);
+  if (existing) return existing;
+  nextUnstableSelectorSeq += 1;
+  const selectorId = `rq_u${nextUnstableSelectorSeq}`;
+  unstableSelectorIdByFn.set(selector, selectorId);
+  return selectorId;
+};
+var unwrapParens = (input) => {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner.startsWith("(") || !inner.endsWith(")")) {
+      return inner;
+    }
+  }
+  return trimmed;
+};
+var extractArrow = (source) => {
+  const idx = source.indexOf("=>");
+  if (idx < 0) return void 0;
+  const left = source.slice(0, idx).trim();
+  const right = source.slice(idx + 2).trim();
+  const paramRaw = unwrapParens(left);
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(paramRaw)) return void 0;
+  if (right.startsWith("{")) {
+    const m = right.match(/^\{\s*return\s+(.+?);?\s*\}\s*$/s);
+    if (!m) return void 0;
+    return { param: paramRaw, body: m[1]?.trim() ?? "" };
+  }
+  return { param: paramRaw, body: right };
+};
+var extractFunctionReturn = (source) => {
+  const trimmed = source.trim();
+  const m = trimmed.match(
+    /^function\s*(?:[A-Za-z_$][A-Za-z0-9_$]*\s*)?\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\)\s*\{\s*return\s+(.+?);?\s*\}\s*$/s
+  );
+  if (!m) return void 0;
+  const param = m[1]?.trim() ?? "";
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(param)) return void 0;
+  const body = m[2]?.trim() ?? "";
+  if (body.length === 0) return void 0;
+  return { param, body };
+};
+var tryParseSelectorSource = (source) => {
+  const arrowOrFn = extractArrow(source) ?? extractFunctionReturn(source);
+  if (!arrowOrFn) return void 0;
+  const expr = unwrapParens(arrowOrFn.body).trim().replace(/;$/, "").trim();
+  {
+    const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+    const m = expr.match(re);
+    if (m) {
+      return { kind: "path", path: m[1] };
+    }
+  }
+  if (expr.startsWith("{") && expr.endsWith("}")) {
+    const inner = expr.slice(1, -1).trim();
+    if (inner.length === 0) return { kind: "struct", entries: [] };
+    const parts = inner.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    const entries = [];
+    for (const part of parts) {
+      const idx = part.indexOf(":");
+      if (idx < 0) return void 0;
+      const key = part.slice(0, idx).trim();
+      const value = part.slice(idx + 1).trim();
+      if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) return void 0;
+      const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+      const m = value.match(re);
+      if (!m) return void 0;
+      entries.push([key, m[1]]);
+    }
+    entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    return { kind: "struct", entries };
+  }
+  return void 0;
+};
+var READ_QUERY_TEMPLATE_CACHE_MAX = 2048;
+var readQueryTemplateByFn = /* @__PURE__ */ new WeakMap();
+var readQueryTemplateBySource = /* @__PURE__ */ new Map();
+var lruGet = (map, key) => {
+  const value = map.get(key);
+  if (value === void 0) return void 0;
+  map.delete(key);
+  map.set(key, value);
+  return value;
+};
+var lruSet = (map, key, value, maxSize) => {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  if (map.size <= maxSize) return;
+  const oldestKey = map.keys().next().value;
+  if (oldestKey !== void 0) {
+    map.delete(oldestKey);
+  }
+};
+var safeToString = (fn) => {
+  try {
+    return fn.toString();
+  } catch {
+    return "";
+  }
+};
+var compile = (input) => {
+  if (isReadQuery(input)) {
+    const reads = normalizeReads(input.reads);
+    const readsDigest = reads.length > 0 ? makeReadsDigest(reads) : void 0;
+    const equalsKind = input.equalsKind;
+    const staticIr2 = {
+      selectorId: input.selectorId,
+      debugKey: input.debugKey,
+      lane: "static",
+      producer: "manual",
+      reads,
+      readsDigest,
+      equalsKind
+    };
+    return {
+      ...input,
+      reads,
+      lane: "static",
+      producer: "manual",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const selector = input;
+  const debugKey = (typeof selector?.debugKey === "string" && selector.debugKey.length > 0 ? selector.debugKey : void 0) ?? (typeof selector.name === "string" && selector.name.length > 0 ? selector.name : void 0);
+  const declaredReads = Array.isArray(selector?.fieldPaths) ? selector.fieldPaths.filter((x) => typeof x === "string") : void 0;
+  if (declaredReads && declaredReads.length > 0) {
+    const reads = normalizeReads(declaredReads);
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "reads", reads });
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const cachedByFn = readQueryTemplateByFn.get(selector);
+  if (cachedByFn) {
+    const staticIr2 = {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedByFn.reads,
+      readsDigest: cachedByFn.readsDigest,
+      equalsKind: cachedByFn.equalsKind
+    };
+    return {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      reads: cachedByFn.reads,
+      select: selector,
+      equalsKind: cachedByFn.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedByFn.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const srcTrimmed = safeToString(selector).trim();
+  const cachedBySource = srcTrimmed.length > 0 ? lruGet(readQueryTemplateBySource, srcTrimmed) : void 0;
+  if (cachedBySource) {
+    readQueryTemplateByFn.set(selector, cachedBySource);
+    const staticIr2 = {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedBySource.reads,
+      readsDigest: cachedBySource.readsDigest,
+      equalsKind: cachedBySource.equalsKind
+    };
+    return {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      reads: cachedBySource.reads,
+      select: selector,
+      equalsKind: cachedBySource.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedBySource.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const parsed = srcTrimmed.length > 0 ? tryParseSelectorSource(srcTrimmed) : void 0;
+  if (parsed?.kind === "path") {
+    const reads = [parsed.path];
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "path", path: parsed.path });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "objectIs" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  if (parsed?.kind === "struct") {
+    const reads = normalizeReads(parsed.entries.map(([, path]) => path));
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "struct", entries: parsed.entries });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "shallowStruct" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "shallowStruct"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "shallowStruct",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const baseFallbackReason = srcTrimmed.includes("=>") || srcTrimmed.startsWith("function") ? "unsupportedSyntax" : "missingDeps";
+  const lowDiscriminabilitySource = srcTrimmed.length === 0 || srcTrimmed.includes("[native code]");
+  const fallbackReason = !debugKey || lowDiscriminabilitySource ? "unstableSelectorId" : baseFallbackReason;
+  const selectorId = fallbackReason === "unstableSelectorId" ? computeUnstableSelectorId(selector) : computeSelectorId({ kind: "dynamic", debugKey, src: srcTrimmed });
+  const staticIr = {
+    selectorId,
+    debugKey,
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    equalsKind: "objectIs"
+  };
+  return {
+    selectorId,
+    debugKey,
+    reads: [],
+    select: selector,
+    equalsKind: "objectIs",
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    staticIr
+  };
+};
+
+// src/internal/runtime/core/diagnosticsBudget.ts
+var DIAGNOSTICS_BUDGET_CONTRACT_V1 = "diagnostics_budget.v1";
+var normalizePositiveInteger = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return Math.floor(value);
+};
+var makeRunBudgetEnvelopeV1 = (args) => {
+  const maxEvents = normalizePositiveInteger(args.limits?.maxEvents);
+  const maxBytes = normalizePositiveInteger(args.limits?.maxBytes);
+  const emitted = normalizePositiveInteger(args.usage?.emitted);
+  const dropped = normalizePositiveInteger(args.usage?.dropped);
+  const downgraded = normalizePositiveInteger(args.usage?.downgraded);
+  return {
+    contract: DIAGNOSTICS_BUDGET_CONTRACT_V1,
+    domain: args.domain,
+    runId: args.runId,
+    ...maxEvents !== void 0 || maxBytes !== void 0 ? {
+      limits: {
+        ...maxEvents !== void 0 ? { maxEvents } : null,
+        ...maxBytes !== void 0 ? { maxBytes } : null
+      }
+    } : null,
+    ...emitted !== void 0 || dropped !== void 0 || downgraded !== void 0 ? {
+      usage: {
+        ...emitted !== void 0 ? { emitted } : null,
+        ...dropped !== void 0 ? { dropped } : null,
+        ...downgraded !== void 0 ? { downgraded } : null
+      }
+    } : null
+  };
+};
+var makeRunDegradeMarkerV1 = (degraded, reason) => ({
+  contract: DIAGNOSTICS_BUDGET_CONTRACT_V1,
+  degraded,
+  ...degraded && reason ? { reason } : null
+});
 
 // src/internal/runtime/core/FlowRuntime.ts
-var getMiddlewareStack = () => import_effect9.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
-  import_effect9.Effect.map((maybe) => import_effect9.Option.isSome(maybe) ? maybe.value.stack : [])
+var getMiddlewareStack = () => import_effect13.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect13.Effect.map((maybe) => import_effect13.Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var getRuntimeScope = (runtime) => {
   if (!runtime) return {};
@@ -629,13 +1715,74 @@ var getRuntimeScope = (runtime) => {
     instanceId: typeof scope.instanceId === "string" ? scope.instanceId : void 0
   };
 };
-var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
-var make2 = (runtime, runtimeInternals) => {
+var hasChangesReadQueryWithMeta = (candidate) => {
+  if (candidate == null) return false;
+  if (typeof candidate !== "object" && typeof candidate !== "function") return false;
+  return typeof candidate.changesReadQueryWithMeta === "function";
+};
+var preResolveEffectResolver = (eff) => {
+  if (typeof eff === "function") {
+    return eff;
+  }
+  return () => eff;
+};
+var resolveFlowRunId = (name, meta, fallbackRunSeq) => {
+  const explicitRunId = meta.runId;
+  if (typeof explicitRunId === "string" && explicitRunId.length > 0) {
+    return explicitRunId;
+  }
+  const instanceId = typeof meta.instanceId === "string" && meta.instanceId.length > 0 ? meta.instanceId : "global";
+  const opSeq = meta.opSeq;
+  if (typeof opSeq === "number" && Number.isFinite(opSeq) && opSeq >= 1) {
+    return `${instanceId}::${name}::r${Math.floor(opSeq)}`;
+  }
+  if (typeof fallbackRunSeq === "number" && Number.isFinite(fallbackRunSeq) && fallbackRunSeq >= 1) {
+    return `${instanceId}::${name}::r${Math.floor(fallbackRunSeq)}`;
+  }
+  return `${instanceId}::${name}`;
+};
+var withFlowRunBudgetMeta = (name, meta, fallbackRunSeq) => {
+  const disableObservers = typeof meta.policy === "object" && meta.policy !== null && meta.policy.disableObservers === true;
+  return {
+    ...meta,
+    budgetEnvelope: makeRunBudgetEnvelopeV1({
+      domain: "flow",
+      runId: resolveFlowRunId(name, meta, fallbackRunSeq)
+    }),
+    degrade: makeRunDegradeMarkerV1(disableObservers, disableObservers ? "observer_disabled" : void 0)
+  };
+};
+var isRunConfig = (input) => {
+  if (!input || typeof input !== "object") {
+    return false;
+  }
+  const candidate = input;
+  if (!("effect" in candidate)) {
+    return false;
+  }
+  const mode = candidate.mode;
+  if (mode === void 0) {
+    return true;
+  }
+  return mode === "task" || mode === "parallel" || mode === "latest" || mode === "exhaust";
+};
+var make3 = (runtime, runtimeInternals) => {
+  let flowBudgetRunSeq = 0;
   const scope = getRuntimeScope(runtime);
-  const resolveConcurrencyLimit2 = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect9.Effect.map((p) => p.concurrencyLimit)) : import_effect9.Effect.succeed(16);
-  const runAsFlowOp = (name, payload, eff, options) => import_effect9.Effect.gen(function* () {
+  const resolveConcurrencyLimit2 = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect13.Effect.map((p) => p.concurrencyLimit)) : import_effect13.Effect.succeed(16);
+  const makeFlowOpRunContext = (options) => import_effect13.Effect.gen(function* () {
     const stack = yield* getMiddlewareStack();
-    const meta = {
+    if (stack.length === 0) {
+      return {
+        stack,
+        hasMiddleware: false,
+        metaTemplate: {},
+        hasFiniteTemplateOpSeq: false,
+        allocateOpSeq: void 0
+      };
+    }
+    const sessionOpt = yield* import_effect13.Effect.serviceOption(RunSessionTag);
+    const metaTemplate = {
       ...options?.meta ?? {},
       policy: options?.policy,
       tags: options?.tags,
@@ -643,112 +1790,146 @@ var make2 = (runtime, runtimeInternals) => {
       moduleId: scope.moduleId,
       instanceId: scope.instanceId
     };
-    if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
-      const sessionOpt = yield* import_effect9.Effect.serviceOption(RunSessionTag);
-      if (import_effect9.Option.isSome(sessionOpt)) {
-        const key = meta.instanceId ?? "global";
-        meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
-      }
+    const hasFiniteTemplateOpSeq = typeof metaTemplate.opSeq === "number" && Number.isFinite(metaTemplate.opSeq);
+    const runSessionLocal = import_effect13.Option.isSome(sessionOpt) ? sessionOpt.value.local : void 0;
+    const opSeqKey = metaTemplate.instanceId ?? "global";
+    const allocateOpSeq = runSessionLocal ? () => runSessionLocal.nextSeq("opSeq", opSeqKey) : void 0;
+    return {
+      stack,
+      hasMiddleware: true,
+      metaTemplate,
+      hasFiniteTemplateOpSeq,
+      allocateOpSeq
+    };
+  });
+  const buildFlowOpMeta = (context) => {
+    if (context.hasFiniteTemplateOpSeq) {
+      return { ...context.metaTemplate };
     }
-    const op = make({
-      kind: "flow",
-      name,
-      payload,
-      effect: eff,
-      meta
+    if (context.allocateOpSeq) {
+      return {
+        ...context.metaTemplate,
+        opSeq: context.allocateOpSeq()
+      };
+    }
+    return context.metaTemplate;
+  };
+  const runAsFlowOp = (context, name, payload, eff) => {
+    if (!context.hasMiddleware) {
+      return eff;
+    }
+    return import_effect13.Effect.gen(function* () {
+      flowBudgetRunSeq += 1;
+      const meta = withFlowRunBudgetMeta(name, buildFlowOpMeta(context), flowBudgetRunSeq);
+      const op = make2({
+        kind: "flow",
+        name,
+        payload,
+        effect: eff,
+        meta
+      });
+      return yield* run(op, context.stack);
+    });
+  };
+  const makeFlowOpMapper = (context, name, resolver) => {
+    if (!context.hasMiddleware) {
+      return resolver;
+    }
+    return (payload) => runAsFlowOp(context, name, payload, resolver(payload));
+  };
+  const runStreamWithMode = (mode, name, resolver, options) => (stream) => import_effect13.Effect.gen(function* () {
+    const context = yield* makeFlowOpRunContext(options);
+    const mapper = makeFlowOpMapper(context, name, resolver);
+    return yield* runByMode({
+      stream,
+      mode,
+      run: mapper,
+      resolveConcurrencyLimit: resolveConcurrencyLimit2(),
+      latest: {
+        strategy: "switch"
+      }
     });
-    return yield* run(op, stack);
   });
-  const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
-  const runStreamSequential = (eff, options) => (stream) => import_effect9.Stream.runForEach(
-    stream,
-    (payload) => runAsFlowOp("flow.run", payload, runEffect(eff)(payload), options)
+  const runStreamParallelWithDiagnostics = (resolver, options) => (stream) => runStreamWithMode("parallel", "flow.runParallel", resolver, options)(stream).pipe(
+    import_effect13.Effect.catchCause((cause) => record({
+      type: "diagnostic",
+      moduleId: scope.moduleId,
+      instanceId: scope.instanceId,
+      code: "flow::unhandled_failure",
+      severity: "error",
+      message: "Flow watcher (runParallel) failed with an unhandled error.",
+      hint: "Handle errors explicitly inside the watcher (catch/catchAll) or write back via TaskRunner failure; avoid silent failures.",
+      kind: "flow_unhandled_failure",
+      trigger: {
+        kind: "flow",
+        name: "runParallel"
+      }
+    }).pipe(import_effect13.Effect.flatMap(() => import_effect13.Effect.failCause(cause))))
   );
-  const runStreamParallel = (eff, options) => (stream) => import_effect9.Effect.gen(function* () {
-    const concurrency = yield* resolveConcurrencyLimit2();
-    return yield* import_effect9.Stream.runDrain(
-      stream.pipe(
-        import_effect9.Stream.mapEffect(
-          (payload) => runAsFlowOp("flow.runParallel", payload, runEffect(eff)(payload), options),
-          { concurrency }
-        )
-      )
-    ).pipe(
-      import_effect9.Effect.catchAllCause(
-        (cause) => record({
-          type: "diagnostic",
-          moduleId: scope.moduleId,
-          instanceId: scope.instanceId,
-          code: "flow::unhandled_failure",
-          severity: "error",
-          message: "Flow watcher (runParallel) failed with an unhandled error.",
-          hint: "Handle errors explicitly inside the watcher (catch/catchAll) or write back via TaskRunner failure; avoid silent failures.",
-          kind: "flow_unhandled_failure",
-          trigger: {
-            kind: "flow",
-            name: "runParallel"
-          }
-        }).pipe(import_effect9.Effect.zipRight(import_effect9.Effect.failCause(cause)))
-      )
-    );
-  });
+  const fromState = (selectorOrQuery) => {
+    const runtimeWithReadQueryMeta = hasChangesReadQueryWithMeta(runtime) ? runtime : void 0;
+    if (isReadQuery(selectorOrQuery)) {
+      if (runtimeWithReadQueryMeta) {
+        return runtimeWithReadQueryMeta.changesReadQueryWithMeta(selectorOrQuery).pipe(import_effect13.Stream.map((evt) => evt.value));
+      }
+      return runtime.changes(selectorOrQuery.select);
+    }
+    if (!runtimeWithReadQueryMeta) {
+      return runtime.changes(selectorOrQuery);
+    }
+    const compiled = compile(selectorOrQuery);
+    if (compiled.lane === "static") {
+      return runtimeWithReadQueryMeta.changesReadQueryWithMeta(compiled).pipe(import_effect13.Stream.map((evt) => evt.value));
+    }
+    return runtime.changes(selectorOrQuery);
+  };
   return {
-    fromAction: (predicate) => runtime.actions$.pipe(import_effect9.Stream.filter(predicate)),
-    fromState: (selectorOrQuery) => runtime.changes(isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),
-    debounce: (ms) => (stream) => import_effect9.Stream.debounce(stream, ms),
-    throttle: (ms) => (stream) => import_effect9.Stream.throttle(stream, {
+    fromAction: (predicate) => runtime.actions$.pipe(import_effect13.Stream.filter(predicate)),
+    fromState,
+    debounce: (ms) => (stream) => import_effect13.Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => import_effect13.Stream.throttle(stream, {
       cost: () => 1,
       units: 1,
       duration: ms,
       strategy: "enforce"
     }),
-    filter: (predicate) => (stream) => import_effect9.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_effect9.Stream.runDrain(
-      import_effect9.Stream.map(
-        stream,
-        (payload) => runAsFlowOp(
-          "flow.runLatest",
-          payload,
-          runEffect(eff)(payload),
-          options
-        )
-      ).pipe(
-        import_effect9.Stream.flatMap((effect) => import_effect9.Stream.fromEffect(effect), {
-          switch: true
-        })
-      )
-    ),
-    runExhaust: (eff, options) => (stream) => import_effect9.Effect.gen(function* () {
-      const concurrency = yield* resolveConcurrencyLimit2();
-      const busyRef = yield* import_effect9.Ref.make(false);
-      const mapper = (payload) => import_effect9.Effect.gen(function* () {
-        const acquired = yield* import_effect9.Ref.modify(
-          busyRef,
-          (busy) => busy ? [false, busy] : [true, true]
-        );
-        if (!acquired) {
-          return;
-        }
-        try {
-          yield* runAsFlowOp(
-            "flow.runExhaust",
-            payload,
-            runEffect(eff)(payload),
-            options
-          );
-        } finally {
-          yield* import_effect9.Ref.set(busyRef, false);
-        }
-      });
-      return yield* import_effect9.Stream.runDrain(stream.pipe(import_effect9.Stream.mapEffect(mapper, { concurrency })));
-    })
+    filter: (predicate) => (stream) => import_effect13.Stream.filter(stream, predicate),
+    run: (effOrConfig, options) => (stream) => {
+      const mode = isRunConfig(effOrConfig) ? effOrConfig.mode ?? "task" : "task";
+      const resolvedOptions = isRunConfig(effOrConfig) ? effOrConfig.options : options;
+      const effect = isRunConfig(effOrConfig) ? effOrConfig.effect : effOrConfig;
+      const resolver = preResolveEffectResolver(effect);
+      if (mode === "parallel") {
+        return runStreamParallelWithDiagnostics(resolver, resolvedOptions)(stream);
+      }
+      return runStreamWithMode(
+        mode,
+        mode === "latest" ? "flow.runLatest" : mode === "exhaust" ? "flow.runExhaust" : "flow.run",
+        resolver,
+        resolvedOptions
+      )(stream);
+    },
+    runParallel: (eff, options) => (stream) => runStreamParallelWithDiagnostics(
+      preResolveEffectResolver(eff),
+      options
+    )(stream),
+    runLatest: (eff, options) => (stream) => runStreamWithMode(
+      "latest",
+      "flow.runLatest",
+      preResolveEffectResolver(eff),
+      options
+    )(stream),
+    runExhaust: (eff, options) => (stream) => runStreamWithMode(
+      "exhaust",
+      "flow.runExhaust",
+      preResolveEffectResolver(eff),
+      options
+    )(stream)
   };
 };
 
 // src/internal/runtime/core/MatchBuilder.ts
-var import_effect10 = require("effect");
+var import_effect14 = require("effect");
 var makeMatch = (value) => {
   let result;
   const chain = {
@@ -767,7 +1948,7 @@ var makeMatch = (value) => {
       if (result) {
         return result;
       }
-      return import_effect10.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
+      return import_effect14.Effect.die(new Error("[FluentMatch] Non-exhaustive match: no pattern matched value"));
     }
   };
   return chain;
@@ -790,24 +1971,27 @@ var makeMatchTag = (value) => {
       if (result) {
         return result;
       }
-      return import_effect10.Effect.dieMessage("[FluentMatchTag] Non-exhaustive match: no tag handler matched value");
+      return import_effect14.Effect.die(new Error("[FluentMatchTag] Non-exhaustive match: no tag handler matched value"));
     }
   };
   return chain;
 };
 
 // src/internal/runtime/core/Platform.ts
-var import_effect11 = require("effect");
-var Tag = import_effect11.Context.GenericTag("@logixjs/Platform");
+var import_effect15 = require("effect");
+var Tag = class extends import_effect15.ServiceMap.Service()("@logixjs/Platform") {
+};
 
 // src/internal/runtime/core/Lifecycle.ts
-var import_effect12 = require("effect");
-var LifecycleContext = import_effect12.Context.GenericTag("@logixjs/LifecycleManager");
+var import_effect16 = require("effect");
+var LifecycleContext = class extends import_effect16.ServiceMap.Service()("@logixjs/LifecycleManager") {
+};
 
 // src/internal/runtime/core/LogicDiagnostics.ts
-var import_effect13 = require("effect");
-var LogicPhaseServiceTag = import_effect13.Context.GenericTag("@logixjs/LogicPhaseService");
-var LogicUnitServiceTag = class extends import_effect13.Context.Tag("@logixjs/LogicUnitService")() {
+var import_effect17 = require("effect");
+var LogicPhaseServiceTag = class extends import_effect17.ServiceMap.Service()("@logixjs/LogicPhaseService") {
+};
+var LogicUnitServiceTag = class extends import_effect17.ServiceMap.Service()("@logixjs/LogicUnitService") {
 };
 var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(new Error(`[LogicPhaseError] ${api} is not allowed in ${phase} phase (kind=${kind}).`), {
   _tag: "LogicPhaseError",
@@ -818,11 +2002,11 @@ var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(new Erro
 });
 
 // src/internal/root.ts
-var import_effect15 = require("effect");
+var import_effect19 = require("effect");
 
 // src/internal/runtime/core/RootContext.ts
-var import_effect14 = require("effect");
-var RootContextTagImpl = class extends import_effect14.Context.Tag("@logixjs/core/RootContext")() {
+var import_effect18 = require("effect");
+var RootContextTagImpl = class extends import_effect18.ServiceMap.Service()("@logixjs/core/RootContext") {
 };
 var RootContextTag = RootContextTagImpl;
 
@@ -857,19 +2041,19 @@ ${extra}` : "",
   err.fix = fix;
   return err;
 };
-var resolve2 = (tag, options) => import_effect15.Effect.gen(function* () {
+var resolve2 = (tag, options) => import_effect19.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);
+  const root = yield* import_effect19.Effect.service(RootContextTag).pipe(import_effect19.Effect.orDie);
+  const rootContext = root.context ?? (options?.waitForReady ? yield* import_effect19.Deferred.await(root.ready) : void 0);
   if (!rootContext) {
-    return yield* import_effect15.Effect.die(
+    return yield* import_effect19.Effect.die(
       makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
     );
   }
   try {
-    return import_effect15.Context.get(rootContext, tag);
+    return import_effect19.ServiceMap.get(rootContext, tag);
   } catch {
-    return yield* import_effect15.Effect.die(makeMissingRootProviderError(tag, entrypoint));
+    return yield* import_effect19.Effect.die(makeMissingRootProviderError(tag, entrypoint));
   }
 });
 
@@ -919,8 +2103,18 @@ var getRuntimeInternals = (runtime) => {
 };
 
 // src/internal/runtime/core/BoundApiRuntime.ts
+var DIRECT_STATE_WRITE_EFFECT = /* @__PURE__ */ Symbol.for("logix.directStateWriteEffect");
+var markDirectStateWriteEffect = (effect, metadata) => {
+  ;
+  effect[DIRECT_STATE_WRITE_EFFECT] = metadata;
+  return effect;
+};
+var getDirectStateWriteMetadata = (value) => {
+  if (!value || typeof value !== "object" && typeof value !== "function") return void 0;
+  return value[DIRECT_STATE_WRITE_EFFECT];
+};
 var LogicBuilderFactory = (runtime, runtimeInternals) => {
-  const flowApi = make2(runtime, runtimeInternals);
+  const flowApi = make3(runtime, runtimeInternals);
   return (stream, triggerName) => {
     const runWithStateTransaction = (origin, body) => runtimeInternals.txn.runWithStateTransaction(origin, body);
     const taskRunnerRuntime = {
@@ -933,7 +2127,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_effect16.Stream.map(f)), triggerName),
+      map: (f) => LogicBuilderFactory(runtime, runtimeInternals)(stream.pipe(import_effect20.Stream.map(f)), triggerName),
       run(eff, options) {
         return flowApi.run(eff, options)(stream);
       },
@@ -946,8 +2140,30 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
       runParallel(eff, options) {
         return flowApi.runParallel(eff, options)(stream);
       },
-      runFork: (eff) => import_effect16.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect16.Effect.asVoid),
-      runParallelFork: (eff) => import_effect16.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect16.Effect.asVoid),
+      runFork: (eff) => {
+        if (runtimeInternals && triggerName && typeof eff !== "function" && getDirectStateWriteMetadata(eff) != null) {
+          return import_effect20.Effect.sync(() => {
+            const metadata = getDirectStateWriteMetadata(eff);
+            runtimeInternals.txn.registerActionStateWriteback(
+              triggerName,
+              metadata.kind === "update" ? { kind: "update", run: metadata.run } : { kind: "mutate", run: metadata.run }
+            );
+          });
+        }
+        return import_effect20.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect20.Effect.asVoid);
+      },
+      runParallelFork: (eff) => {
+        if (runtimeInternals && triggerName && typeof eff !== "function" && getDirectStateWriteMetadata(eff) != null) {
+          return import_effect20.Effect.sync(() => {
+            const metadata = getDirectStateWriteMetadata(eff);
+            runtimeInternals.txn.registerActionStateWriteback(
+              triggerName,
+              metadata.kind === "update" ? { kind: "update", run: metadata.run } : { kind: "mutate", run: metadata.run }
+            );
+          });
+        }
+        return import_effect20.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect20.Effect.asVoid);
+      },
       runTask: (config) => makeTaskRunner(stream, "task", taskRunnerRuntime, {
         ...config,
         triggerName: config.triggerName ?? triggerName
@@ -965,20 +2181,20 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
         triggerName: config.triggerName ?? triggerName
       }),
       toStream: () => stream,
-      update: (reducer) => import_effect16.Stream.runForEach(
+      update: (reducer) => import_effect20.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:update",
             name: triggerName
           },
-          () => import_effect16.Effect.gen(function* () {
+          () => import_effect20.Effect.gen(function* () {
             const prev = yield* runtime.getState;
             const next = reducer(prev, payload);
-            if (import_effect16.Effect.isEffect(next)) {
-              const exit = yield* import_effect16.Effect.exit(next);
+            if (import_effect20.Effect.isEffect(next)) {
+              const exit = yield* import_effect20.Effect.exit(next);
               if (exit._tag === "Failure") {
-                yield* import_effect16.Effect.logError("Flow error", exit.cause);
+                yield* import_effect20.Effect.logError("Flow error", exit.cause);
                 return;
               }
               yield* runtime.setState(exit.value);
@@ -987,15 +2203,15 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             yield* runtime.setState(next);
           })
         )
-      ).pipe(import_effect16.Effect.catchAllCause((cause) => import_effect16.Effect.logError("Flow error", cause))),
-      mutate: (reducer) => import_effect16.Stream.runForEach(
+      ).pipe(import_effect20.Effect.catchCause((cause) => import_effect20.Effect.logError("Flow error", cause))),
+      mutate: (reducer) => import_effect20.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:mutate",
             name: triggerName
           },
-          () => import_effect16.Effect.gen(function* () {
+          () => import_effect20.Effect.gen(function* () {
             const prev = yield* runtime.getState;
             const recordPatch = runtimeInternals.txn.recordStatePatch;
             const updateDraft = runtimeInternals.txn.updateDraft;
@@ -1008,7 +2224,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             updateDraft(nextState);
           })
         )
-      ).pipe(import_effect16.Effect.catchAllCause((cause) => import_effect16.Effect.logError("Flow error", cause)))
+      ).pipe(import_effect20.Effect.catchCause((cause) => import_effect20.Effect.logError("Flow error", cause)))
     };
     const pipe = function() {
       const fns = arguments;
@@ -1021,7 +2237,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
     return Object.assign(builder, { pipe });
   };
 };
-function make3(shape, runtime, options) {
+function make4(shape, runtime, options) {
   const runtimeInternals = getRuntimeInternals(runtime);
   const getPhase = options?.getPhase ?? (() => "run");
   const getCurrentPhase = () => {
@@ -1036,21 +2252,19 @@ function make3(shape, runtime, options) {
       throw makeLogicPhaseError(kind, api2, "setup", options?.moduleId);
     }
   };
-  const flowApi = make2(runtime, runtimeInternals);
+  const flowApi = make3(runtime, runtimeInternals);
   const makeIntentBuilder = (runtime_) => LogicBuilderFactory(runtime_, runtimeInternals);
-  const withLifecycle = (available, missing) => import_effect16.Effect.serviceOption(LifecycleContext).pipe(
-    import_effect16.Effect.flatMap(
-      (maybe) => import_effect16.Option.match(maybe, {
-        onSome: available,
-        onNone: missing
-      })
-    )
+  const withLifecycle = (available, missing) => import_effect20.Effect.serviceOption(LifecycleContext).pipe(
+    import_effect20.Effect.flatMap((maybe) => import_effect20.Option.match(maybe, {
+      onSome: available,
+      onNone: missing
+    }))
   );
-  const withPlatform = (invoke) => import_effect16.Effect.serviceOption(Tag).pipe(
-    import_effect16.Effect.flatMap(
-      (maybe) => import_effect16.Option.match(maybe, {
+  const withPlatform = (invoke) => import_effect20.Effect.serviceOption(Tag).pipe(
+    import_effect20.Effect.flatMap(
+      (maybe) => import_effect20.Option.match(maybe, {
         onSome: invoke,
-        onNone: () => import_effect16.Effect.void
+        onNone: () => import_effect20.Effect.void
       })
     )
   );
@@ -1063,14 +2277,29 @@ function make3(shape, runtime, options) {
     message: `${api2} is setup-only and is not allowed in run phase.`,
     hint: "Move $.lifecycle.* calls to the synchronous part of Module.logic builder (before return) for registration; for dynamic resource cleanup in the run phase, use Effect.acquireRelease / Scope finalizer instead of registering onDestroy late.",
     kind: "lifecycle_in_run"
-  });
+  }).pipe(import_effect20.Effect.orDie);
   const createIntentBuilder = (stream, triggerName) => makeIntentBuilder(runtime)(stream, triggerName);
-  const onceInRunSession = (key) => import_effect16.Effect.serviceOption(RunSessionTag).pipe(
-    import_effect16.Effect.map((maybe) => import_effect16.Option.isSome(maybe) ? maybe.value.local.once(key) : true)
+  const actionMatchesTag = (action, tag) => {
+    const actionTag = action?._tag;
+    if (actionTag === tag) {
+      return true;
+    }
+    const actionType = action?.type;
+    return actionType === tag;
+  };
+  const actionStreamByTag = (tag) => {
+    const topicSelector = runtime.actionsByTag$;
+    if (typeof topicSelector === "function") {
+      return topicSelector(tag);
+    }
+    return runtime.actions$.pipe(import_effect20.Stream.filter((action) => actionMatchesTag(action, tag)));
+  };
+  const onceInRunSession = (key) => import_effect20.Effect.serviceOption(RunSessionTag).pipe(
+    import_effect20.Effect.map((maybe) => import_effect20.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_effect16.Context.isTag(value.tag)
+    value && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value && import_effect20.ServiceMap.isKey(value.tag)
   );
   const buildModuleHandle = (tag, rt) => {
     const actionsProxy = new Proxy(
@@ -1083,7 +2312,7 @@ function make3(shape, runtime, options) {
       }
     );
     const handle = {
-      read: (selector) => import_effect16.Effect.map(rt.getState, selector),
+      read: (selector) => import_effect20.Effect.map(rt.getState, selector),
       changes: rt.changes,
       dispatch: rt.dispatch,
       actions$: rt.actions$,
@@ -1093,7 +2322,7 @@ function make3(shape, runtime, options) {
     const extend = tag?.[EXTEND_HANDLE];
     return typeof extend === "function" ? extend(rt, handle) ?? handle : handle;
   };
-  const emitModuleDescriptorOnce = (module2, rt) => import_effect16.Effect.gen(function* () {
+  const emitModuleDescriptorOnce = (module2, rt) => import_effect20.Effect.gen(function* () {
     if (cachedDiagnosticsLevel === "off") return;
     const key = `module_descriptor:${String(rt.instanceId ?? "unknown")}`;
     const shouldEmit = yield* onceInRunSession(key);
@@ -1133,7 +2362,7 @@ function make3(shape, runtime, options) {
       data
     });
   });
-  const resolveModuleRuntime = (tag) => import_effect16.Effect.gen(function* () {
+  const resolveModuleRuntime = (tag) => import_effect20.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) {
@@ -1144,8 +2373,8 @@ function make3(shape, runtime, options) {
       return fromImports;
     }
     if (typeof options?.moduleId !== "string") {
-      const fromEnv = yield* import_effect16.Effect.serviceOption(tag);
-      if (import_effect16.Option.isSome(fromEnv)) {
+      const fromEnv = yield* import_effect20.Effect.serviceOption(tag);
+      if (import_effect20.Option.isSome(fromEnv)) {
         return fromEnv.value;
       }
     }
@@ -1180,46 +2409,163 @@ function make3(shape, runtime, options) {
     };
     err.fix = fix;
     err.name = "MissingModuleRuntimeError";
-    return yield* import_effect16.Effect.die(err);
+    return yield* import_effect20.Effect.die(err);
   });
-  const stateApi = {
-    read: runtime.getState,
-    update: (f) => import_effect16.Effect.gen(function* () {
-      const inTxn = yield* import_effect16.FiberRef.get(inSyncTransactionFiber);
-      if (inTxn) {
-        const prev = yield* runtime.getState;
-        return yield* runtime.setState(f(prev));
-      }
-      const body = () => import_effect16.Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
-      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "update" }, body) : body();
-    }),
-    mutate: (f) => import_effect16.Effect.gen(function* () {
-      const recordPatch = runtimeInternals?.txn.recordStatePatch;
-      const updateDraft = runtimeInternals?.txn.updateDraft;
-      const inTxn = yield* import_effect16.FiberRef.get(inSyncTransactionFiber);
-      if (inTxn) {
-        const prev = yield* runtime.getState;
-        const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
-          f(draft);
+  let batchedStateWritebackCoordinator;
+  const getOrCreateBatchedStateWritebackCoordinator = () => {
+    if (batchedStateWritebackCoordinator) return batchedStateWritebackCoordinator;
+    if (!runtimeInternals) {
+      throw new Error("[BatchedStateWritebackCoordinator] Missing runtimeInternals (expected in ModuleRuntime-backed $).");
+    }
+    let inFlight = false;
+    const pending = [];
+    const drain = () => {
+      if (pending.length === 0) return [];
+      return pending.splice(0, pending.length);
+    };
+    const ok = { _tag: "ok" };
+    const fail = (cause) => ({ _tag: "failure", cause });
+    const applyBatch = (batch) => import_effect20.Effect.gen(function* () {
+      if (batch.length === 0) return;
+      let current = yield* runtime.getState;
+      for (let i = 0; i < batch.length; i++) {
+        const req = batch[i];
+        if (req.kind === "update") {
+          const next = req.update(current);
+          current = next;
+          yield* runtime.setState(next);
+          continue;
+        }
+        const { nextState, patchPaths } = mutateWithPatchPaths(current, (draft) => {
+          req.mutate(draft);
         });
         for (const path of patchPaths) {
-          recordPatch?.(path, "unknown");
+          runtimeInternals.txn.recordStatePatch(path, "unknown");
         }
-        updateDraft?.(nextState);
-        return;
+        runtimeInternals.txn.updateDraft(nextState);
+        current = nextState;
+      }
+    });
+    const flushInFlight = () => import_effect20.Effect.uninterruptible(
+      import_effect20.Effect.gen(function* () {
+        if (inFlight) return;
+        inFlight = true;
+        try {
+          while (true) {
+            const batch = drain();
+            if (batch.length === 0) {
+              inFlight = false;
+              if (pending.length === 0) return;
+              inFlight = true;
+              continue;
+            }
+            const originName = batch.length === 1 ? batch[0].kind === "update" ? "update" : "mutate" : "writeback:batched";
+            const exit = yield* import_effect20.Effect.exit(
+              runtimeInternals.txn.runWithStateTransaction(
+                {
+                  kind: "state",
+                  name: originName,
+                  details: { batched: true, count: batch.length }
+                },
+                () => applyBatch(batch).pipe(import_effect20.Effect.asVoid)
+              )
+            );
+            const outcome = exit._tag === "Success" ? ok : fail(exit.cause);
+            for (let i = 0; i < batch.length; i++) {
+              yield* import_effect20.Deferred.succeed(batch[i].done, outcome);
+            }
+            if (outcome._tag === "failure") {
+              return;
+            }
+          }
+        } finally {
+          inFlight = false;
+        }
+      })
+    );
+    const waitForMicrotask = () => import_effect20.Effect.promise(
+      () => new Promise((resolve3) => {
+        if (typeof queueMicrotask === "function") {
+          queueMicrotask(resolve3);
+          return;
+        }
+        Promise.resolve().then(resolve3);
+      })
+    );
+    const enqueueAndAwait = (req) => import_effect20.Effect.gen(function* () {
+      pending.push(req);
+      if (!inFlight) {
+        yield* waitForMicrotask();
+      }
+      yield* flushInFlight();
+      const outcome = yield* import_effect20.Deferred.await(req.done);
+      if (outcome._tag === "failure") {
+        return yield* import_effect20.Effect.die(outcome.cause);
       }
-      const body = () => import_effect16.Effect.gen(function* () {
-        const prev = yield* runtime.getState;
-        const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
-          f(draft);
+    });
+    const coordinator = {
+      enqueueUpdate: (update) => import_effect20.Effect.gen(function* () {
+        const done = yield* import_effect20.Deferred.make();
+        yield* enqueueAndAwait({ kind: "update", update, done });
+      }),
+      enqueueMutate: (mutate) => import_effect20.Effect.gen(function* () {
+        const done = yield* import_effect20.Deferred.make();
+        yield* enqueueAndAwait({ kind: "mutate", mutate, done });
+      })
+    };
+    batchedStateWritebackCoordinator = coordinator;
+    return coordinator;
+  };
+  const stateApi = {
+    read: runtime.getState,
+    update: (f) => markDirectStateWriteEffect(
+      import_effect20.Effect.gen(function* () {
+        const inTxn = yield* import_effect20.Effect.service(inSyncTransactionFiber).pipe(import_effect20.Effect.orDie);
+        if (inTxn) {
+          const prev = yield* runtime.getState;
+          return yield* runtime.setState(f(prev));
+        }
+        const body = () => import_effect20.Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
+        if (runtimeInternals && !isDevEnv()) {
+          return yield* getOrCreateBatchedStateWritebackCoordinator().enqueueUpdate(f);
+        }
+        return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "update" }, body) : body();
+      }),
+      { kind: "update", run: f }
+    ),
+    mutate: (f) => markDirectStateWriteEffect(
+      import_effect20.Effect.gen(function* () {
+        const recordPatch = runtimeInternals?.txn.recordStatePatch;
+        const updateDraft = runtimeInternals?.txn.updateDraft;
+        const inTxn = yield* import_effect20.Effect.service(inSyncTransactionFiber).pipe(import_effect20.Effect.orDie);
+        if (inTxn) {
+          const prev = yield* runtime.getState;
+          const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
+            f(draft);
+          });
+          for (const path of patchPaths) {
+            recordPatch?.(path, "unknown");
+          }
+          updateDraft?.(nextState);
+          return;
+        }
+        const body = () => import_effect20.Effect.gen(function* () {
+          const prev = yield* runtime.getState;
+          const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
+            f(draft);
+          });
+          for (const path of patchPaths) {
+            recordPatch?.(path, "unknown");
+          }
+          updateDraft?.(nextState);
         });
-        for (const path of patchPaths) {
-          recordPatch?.(path, "unknown");
+        if (runtimeInternals && !isDevEnv()) {
+          return yield* getOrCreateBatchedStateWritebackCoordinator().enqueueMutate(f);
         }
-        updateDraft?.(nextState);
-      });
-      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "mutate" }, body) : body();
-    }),
+        return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "mutate" }, body) : body();
+      }),
+      { kind: "mutate", run: f }
+    ),
     ref: runtime.ref
   };
   const actions = shape.actionMap;
@@ -1257,13 +2603,13 @@ function make3(shape, runtime, options) {
   const matchApi = (value) => makeMatch(value);
   const matchTagApi = (value) => makeMatchTag(value);
   const reducer = (tag, fn) => {
-    return import_effect16.Effect.sync(() => {
+    return import_effect20.Effect.sync(() => {
       runtimeInternals.txn.registerReducer(String(tag), fn);
     });
   };
-  const effect = (token, handler) => import_effect16.Effect.gen(function* () {
+  const effect = (token, handler) => import_effect20.Effect.gen(function* () {
     if (!isActionToken(token)) {
-      return yield* import_effect16.Effect.dieMessage("[BoundApi.effect] token must be an ActionToken");
+      return yield* import_effect20.Effect.die(new Error("[BoundApi.effect] token must be an ActionToken"));
     }
     const phase = getCurrentPhase();
     const logicUnit = options?.logicUnit;
@@ -1303,56 +2649,56 @@ function make3(shape, runtime, options) {
           return emitSetupOnlyViolation("$.lifecycle.onInitRequired");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect16.Effect.void;
+        return import_effect20.Effect.void;
       },
       onStart: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onStart");
         }
         runtimeInternals.lifecycle.registerStart(eff);
-        return import_effect16.Effect.void;
+        return import_effect20.Effect.void;
       },
       onInit: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onInit");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect16.Effect.void;
+        return import_effect20.Effect.void;
       },
       onDestroy: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onDestroy");
         }
         runtimeInternals.lifecycle.registerDestroy(eff);
-        return import_effect16.Effect.void;
+        return import_effect20.Effect.void;
       },
       onError: (handler) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onError");
         }
         runtimeInternals.lifecycle.registerOnError(handler);
-        return import_effect16.Effect.void;
+        return import_effect20.Effect.void;
       },
       onSuspend: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onSuspend");
         }
-        runtimeInternals.lifecycle.registerPlatformSuspend(import_effect16.Effect.asVoid(eff));
-        return import_effect16.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformSuspend(import_effect20.Effect.asVoid(eff));
+        return import_effect20.Effect.void;
       },
       onResume: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onResume");
         }
-        runtimeInternals.lifecycle.registerPlatformResume(import_effect16.Effect.asVoid(eff));
-        return import_effect16.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformResume(import_effect20.Effect.asVoid(eff));
+        return import_effect20.Effect.void;
       },
       onReset: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onReset");
         }
-        runtimeInternals.lifecycle.registerPlatformReset(import_effect16.Effect.asVoid(eff));
-        return import_effect16.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformReset(import_effect20.Effect.asVoid(eff));
+        return import_effect20.Effect.void;
       }
     },
     traits: {
@@ -1386,14 +2732,14 @@ function make3(shape, runtime, options) {
         });
       },
       source: {
-        refresh: (fieldPath, options2) => import_effect16.Effect.gen(function* () {
+        refresh: (fieldPath, options2) => import_effect20.Effect.gen(function* () {
           const handler = runtimeInternals.traits.getSourceRefreshHandler(fieldPath);
           if (!handler) {
-            return yield* import_effect16.Effect.void;
+            return yield* import_effect20.Effect.void;
           }
           const force = options2?.force === true;
-          const runHandler = (state) => force ? import_effect16.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
-          const inTxn = yield* import_effect16.FiberRef.get(inSyncTransactionFiber);
+          const runHandler = (state) => force ? import_effect20.Effect.provideService(handler(state), forceSourceRefresh, true) : handler(state);
+          const inTxn = yield* import_effect20.Effect.service(inSyncTransactionFiber).pipe(import_effect20.Effect.orDie);
           if (inTxn) {
             const state = yield* runtime.getState;
             return yield* runHandler(state);
@@ -1403,7 +2749,7 @@ function make3(shape, runtime, options) {
               kind: "source-refresh",
               name: fieldPath
             },
-            () => import_effect16.Effect.gen(function* () {
+            () => import_effect20.Effect.gen(function* () {
               const state = yield* runtime.getState;
               return yield* runHandler(state);
             })
@@ -1420,18 +2766,19 @@ function make3(shape, runtime, options) {
         if (isModuleLike(arg)) {
           const domain = arg;
           const tag = domain.tag;
-          const resolveAndBuild = resolveModuleRuntime(tag).pipe(import_effect16.Effect.map((rt) => buildModuleHandle(tag, rt)));
+          const resolveAndBuild = resolveModuleRuntime(tag).pipe(import_effect20.Effect.map((rt) => buildModuleHandle(tag, rt)));
           const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(
-            import_effect16.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
-            import_effect16.Effect.map((rt) => buildModuleHandle(tag, rt))
+            import_effect20.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
+            import_effect20.Effect.map((rt) => buildModuleHandle(tag, rt))
           );
-          const detectAndSelect = import_effect16.FiberRef.get(currentDiagnosticsLevel).pipe(
-            import_effect16.Effect.tap((level) => {
+          const detectAndSelect = import_effect20.Effect.service(currentDiagnosticsLevel).pipe(
+            import_effect20.Effect.map((level) => {
               cachedDiagnosticsLevel = level;
+              return level;
             }),
-            import_effect16.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
+            import_effect20.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
           );
-          return import_effect16.Effect.suspend(() => {
+          return import_effect20.Effect.suspend(() => {
             if (cachedDiagnosticsLevel === "off") {
               return resolveAndBuild;
             }
@@ -1441,16 +2788,16 @@ function make3(shape, runtime, options) {
             return detectAndSelect;
           });
         }
-        if (import_effect16.Context.isTag(arg)) {
+        if (import_effect20.ServiceMap.isKey(arg)) {
           const candidate = arg;
           if (candidate._kind === "ModuleTag") {
             return resolveModuleRuntime(arg).pipe(
-              import_effect16.Effect.map((rt) => buildModuleHandle(arg, rt))
+              import_effect20.Effect.map((rt) => buildModuleHandle(arg, rt))
             );
           }
-          return arg;
+          return import_effect20.Effect.service(arg).pipe(import_effect20.Effect.orDie);
         }
-        return import_effect16.Effect.die("BoundApi.use: unsupported argument");
+        return import_effect20.Effect.die("BoundApi.use: unsupported argument");
       }
     }),
     onAction: new Proxy(() => {
@@ -1460,39 +2807,33 @@ function make3(shape, runtime, options) {
         const arg = args[0];
         if (isActionToken(arg)) {
           const tag = arg.tag;
+          return createIntentBuilder(actionStreamByTag(tag).pipe(import_effect20.Stream.map((action) => action.payload)), tag);
+        }
+        if (import_effect20.Schema.isSchema(arg)) {
+          const decode = import_effect20.Schema.decodeUnknownSync(arg);
           return createIntentBuilder(
             runtime.actions$.pipe(
-              import_effect16.Stream.filter((a) => a._tag === tag || a.type === tag),
-              import_effect16.Stream.map((a) => a.payload)
-            ),
-            tag
+              import_effect20.Stream.filter((a) => {
+                try {
+                  decode(a);
+                  return true;
+                } catch {
+                  return false;
+                }
+              })
+            )
           );
         }
         if (typeof arg === "function") {
-          return createIntentBuilder(runtime.actions$.pipe(import_effect16.Stream.filter(arg)));
+          return createIntentBuilder(runtime.actions$.pipe(import_effect20.Stream.filter(arg)));
         }
         if (typeof arg === "string") {
-          return createIntentBuilder(
-            runtime.actions$.pipe(import_effect16.Stream.filter((a) => a._tag === arg || a.type === arg)),
-            arg
-          );
+          return createIntentBuilder(actionStreamByTag(arg), arg);
         }
         if (typeof arg === "object" && arg !== null) {
           if ("_tag" in arg) {
-            return createIntentBuilder(
-              runtime.actions$.pipe(import_effect16.Stream.filter((a) => a._tag === arg._tag)),
-              String(arg._tag)
-            );
-          }
-          if (import_effect16.Schema.isSchema(arg)) {
-            return createIntentBuilder(
-              runtime.actions$.pipe(
-                import_effect16.Stream.filter((a) => {
-                  const result = import_effect16.Schema.decodeUnknownSync(arg)(a);
-                  return !!result;
-                })
-              )
-            );
+            const tag = String(arg._tag);
+            return createIntentBuilder(actionStreamByTag(tag), tag);
           }
         }
         return createIntentBuilder(runtime.actions$);
@@ -1500,10 +2841,7 @@ function make3(shape, runtime, options) {
       get: (_target, prop) => {
         guardRunOnly("use_in_setup", "$.onAction");
         if (typeof prop === "string") {
-          return createIntentBuilder(
-            runtime.actions$.pipe(import_effect16.Stream.filter((a) => a._tag === prop || a.type === prop)),
-            prop
-          );
+          return createIntentBuilder(actionStreamByTag(prop), prop);
         }
         return void 0;
       }
@@ -1522,8 +2860,8 @@ function make3(shape, runtime, options) {
 }
 
 // src/Bound.ts
-function make4(shape, runtime) {
-  return make3(shape, runtime);
+function make5(shape, runtime) {
+  return make4(shape, runtime);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {