@logixjs/core 0.0.1 → 1.0.0

package/dist/{chunk-BE3HW4FY.js → chunk-ZBBMZMA6.js}

@@ -1,63 +1,87 @@
-import {
-  forceSourceRefresh,
-  inSyncTransactionFiber,
-  makeTaskRunner
-} from "./chunk-ZFLHVFUC.js";
 import {
   Tag
-} from "./chunk-KL5ACTCT.js";
+} from "./chunk-UEFFTVPY.js";
 import {
   resolve
-} from "./chunk-AUIR5O6W.js";
+} from "./chunk-AFSB6NKM.js";
 import {
   makeMatch,
   makeMatchTag
-} from "./chunk-BZ2SHDN2.js";
+} from "./chunk-SGTRAXXX.js";
 import {
   isActionToken
-} from "./chunk-YS3AZQ2G.js";
+} from "./chunk-6HFAW2MH.js";
 import {
-  isFieldPathSegment
-} from "./chunk-IHVBV5C2.js";
+  isFieldPathSegment,
+  toKey
+} from "./chunk-SOOBFXRR.js";
 import {
   getRuntimeInternals,
   setBoundInternals
-} from "./chunk-3RMKLXHX.js";
+} from "./chunk-63ZQ5RIN.js";
 import {
-  isDevEnv
-} from "./chunk-3QMIVH35.js";
+  forceSourceRefresh,
+  inSyncTransactionFiber,
+  isDevEnv,
+  makeTaskRunner
+} from "./chunk-S4S5N4BJ.js";
 import {
   make
-} from "./chunk-NQZ2OSGR.js";
+} from "./chunk-FBYW3QDI.js";
+import {
+  RunSessionTag
+} from "./chunk-CYYSQMLO.js";
 import {
   currentDiagnosticsLevel,
   record,
   toSerializableErrorSummary
-} from "./chunk-DMBALCE2.js";
-import {
-  RunSessionTag
-} from "./chunk-OFADUJWJ.js";
+} from "./chunk-V2SBGVDO.js";
 
 // src/internal/runtime/core/mutativePatches.ts
 import { create } from "mutative";
 var mutateWithoutPatches = (base, mutator) => {
   return create(base, mutator);
 };
+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 = create(base, mutator, {
@@ -71,25 +95,63 @@ 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/BoundApiRuntime.ts
-import { Context as Context3, Effect as Effect3, FiberRef, Option, Schema, Stream } from "effect";
+import { Deferred, Effect as Effect3, Option, Schema, ServiceMap as ServiceMap3, Stream } from "effect";
 
 // src/internal/runtime/core/Lifecycle.ts
-import { Cause, Context, Effect, Ref } from "effect";
-var LifecycleContext = Context.GenericTag("@logixjs/LifecycleManager");
+import { Cause, Effect, Ref, ServiceMap } from "effect";
+var LifecycleContext = class extends ServiceMap.Service()("@logixjs/LifecycleManager") {
+};
 var safeRun = (label, eff) => eff.pipe(
   Effect.matchCauseEffect({
     onSuccess: () => Effect.void,
@@ -197,7 +259,7 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
     });
   };
   const notifyError = (cause, context) => {
-    if (Cause.isInterrupted(cause)) {
+    if (Cause.hasInterruptsOnly(cause)) {
       return Effect.void;
     }
     return record({
@@ -212,11 +274,11 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
       opSeq: context.opSeq,
       origin: context.origin
     }).pipe(
-      Effect.zipRight(
-        Effect.forEach(
+      Effect.flatMap(
+        () => Effect.forEach(
           onErrorHandlers,
           (handler) => handler(cause, context).pipe(
-            Effect.catchAllCause((inner) => Effect.logError(`[lifecycle.onError] failed: ${Cause.pretty(inner)}`))
+            Effect.catchCause((inner) => Effect.logError(`[lifecycle.onError] failed: ${Cause.pretty(inner)}`))
           ),
           { discard: true }
         )
@@ -275,21 +337,19 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
   const runStart = recordPhase("run", "start:schedule", {
     total: start.length
   }).pipe(
-    Effect.zipRight(
-      Effect.forEach(
+    Effect.flatMap(
+      () => Effect.forEach(
         start,
         (task) => Effect.forkScoped(
           task.effect.pipe(
-            Effect.catchAllCause(
-              (cause) => notifyError(cause, {
-                phase: "run",
-                hook: "start",
-                moduleId: identity.moduleId,
-                instanceId: identity.instanceId,
-                taskId: task.taskId,
-                origin: "start"
-              })
-            )
+            Effect.catchCause((cause) => notifyError(cause, {
+              phase: "run",
+              hook: "start",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "start"
+            }))
           )
         ).pipe(Effect.asVoid),
         { discard: true, concurrency: "unbounded" }
@@ -304,16 +364,14 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
       yield* safeRun(
         "lifecycle.onDestroy",
         task.effect.pipe(
-          Effect.catchAllCause(
-            (cause) => notifyError(cause, {
-              phase: "destroy",
-              hook: "destroy",
-              moduleId: identity.moduleId,
-              instanceId: identity.instanceId,
-              taskId: task.taskId,
-              origin: "destroy"
-            })
-          )
+          Effect.catchCause((cause) => notifyError(cause, {
+            phase: "destroy",
+            hook: "destroy",
+            moduleId: identity.moduleId,
+            instanceId: identity.instanceId,
+            taskId: task.taskId,
+            origin: "destroy"
+          }))
         )
       );
     }
@@ -327,16 +385,14 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
       yield* safeRun(
         "lifecycle.onSuspend",
         task.effect.pipe(
-          Effect.catchAllCause(
-            (cause) => notifyError(cause, {
-              phase: "platform",
-              hook: "suspend",
-              moduleId: identity.moduleId,
-              instanceId: identity.instanceId,
-              taskId: task.taskId,
-              origin: "platform.suspend"
-            })
-          )
+          Effect.catchCause((cause) => notifyError(cause, {
+            phase: "platform",
+            hook: "suspend",
+            moduleId: identity.moduleId,
+            instanceId: identity.instanceId,
+            taskId: task.taskId,
+            origin: "platform.suspend"
+          }))
         )
       );
     }
@@ -348,16 +404,14 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
       yield* safeRun(
         "lifecycle.onResume",
         task.effect.pipe(
-          Effect.catchAllCause(
-            (cause) => notifyError(cause, {
-              phase: "platform",
-              hook: "resume",
-              moduleId: identity.moduleId,
-              instanceId: identity.instanceId,
-              taskId: task.taskId,
-              origin: "platform.resume"
-            })
-          )
+          Effect.catchCause((cause) => notifyError(cause, {
+            phase: "platform",
+            hook: "resume",
+            moduleId: identity.moduleId,
+            instanceId: identity.instanceId,
+            taskId: task.taskId,
+            origin: "platform.resume"
+          }))
         )
       );
     }
@@ -369,16 +423,14 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
       yield* safeRun(
         "lifecycle.onReset",
         task.effect.pipe(
-          Effect.catchAllCause(
-            (cause) => notifyError(cause, {
-              phase: "platform",
-              hook: "reset",
-              moduleId: identity.moduleId,
-              instanceId: identity.instanceId,
-              taskId: task.taskId,
-              origin: "platform.reset"
-            })
-          )
+          Effect.catchCause((cause) => notifyError(cause, {
+            phase: "platform",
+            hook: "reset",
+            moduleId: identity.moduleId,
+            instanceId: identity.instanceId,
+            taskId: task.taskId,
+            origin: "platform.reset"
+          }))
         )
       );
     }
@@ -417,13 +469,13 @@ var makeLifecycleManager = (identity) => Effect.gen(function* () {
 });
 
 // src/internal/runtime/core/LogicDiagnostics.ts
-import { Cause as Cause2, Context as Context2, Effect as Effect2 } from "effect";
+import { Cause as Cause2, Effect as Effect2, ServiceMap as ServiceMap2 } from "effect";
 var phaseDiagnosticsEnabled = () => isDevEnv();
 var SERVICE_NOT_FOUND_PREFIX = "Service not found:";
 var emitEnvServiceNotFoundDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(function* () {
   let pretty;
   try {
-    pretty = Cause2.pretty(cause, { renderErrorCause: true });
+    pretty = Cause2.pretty(cause);
   } catch {
     return;
   }
@@ -448,8 +500,9 @@ var emitEnvServiceNotFoundDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(
     kind: "env_service_not_ready"
   });
 });
-var LogicPhaseServiceTag = Context2.GenericTag("@logixjs/LogicPhaseService");
-var LogicUnitServiceTag = class extends Context2.Tag("@logixjs/LogicUnitService")() {
+var LogicPhaseServiceTag = class extends ServiceMap2.Service()("@logixjs/LogicPhaseService") {
+};
+var LogicUnitServiceTag = class extends ServiceMap2.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",
@@ -462,7 +515,7 @@ var emitInvalidPhaseDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(functi
   if (!phaseDiagnosticsEnabled()) {
     return;
   }
-  const allErrors = [...Cause2.failures(cause), ...Cause2.defects(cause)];
+  const allErrors = cause.reasons.filter((reason) => Cause2.isFailReason(reason) || Cause2.isDieReason(reason)).map((reason) => Cause2.isFailReason(reason) ? reason.error : reason.defect);
   for (const err of allErrors) {
     const logicErr = err;
     if (logicErr && logicErr._tag === "LogicPhaseError") {
@@ -483,6 +536,16 @@ var emitInvalidPhaseDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(functi
 });
 
 // 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 = make(runtime, runtimeInternals);
   return (stream, triggerName) => {
@@ -510,8 +573,30 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
       runParallel(eff, options) {
         return flowApi.runParallel(eff, options)(stream);
       },
-      runFork: (eff) => Effect3.forkScoped(flowApi.run(eff)(stream)).pipe(Effect3.asVoid),
-      runParallelFork: (eff) => Effect3.forkScoped(flowApi.runParallel(eff)(stream)).pipe(Effect3.asVoid),
+      runFork: (eff) => {
+        if (runtimeInternals && triggerName && typeof eff !== "function" && getDirectStateWriteMetadata(eff) != null) {
+          return Effect3.sync(() => {
+            const metadata = getDirectStateWriteMetadata(eff);
+            runtimeInternals.txn.registerActionStateWriteback(
+              triggerName,
+              metadata.kind === "update" ? { kind: "update", run: metadata.run } : { kind: "mutate", run: metadata.run }
+            );
+          });
+        }
+        return Effect3.forkScoped(flowApi.run(eff)(stream)).pipe(Effect3.asVoid);
+      },
+      runParallelFork: (eff) => {
+        if (runtimeInternals && triggerName && typeof eff !== "function" && getDirectStateWriteMetadata(eff) != null) {
+          return Effect3.sync(() => {
+            const metadata = getDirectStateWriteMetadata(eff);
+            runtimeInternals.txn.registerActionStateWriteback(
+              triggerName,
+              metadata.kind === "update" ? { kind: "update", run: metadata.run } : { kind: "mutate", run: metadata.run }
+            );
+          });
+        }
+        return Effect3.forkScoped(flowApi.runParallel(eff)(stream)).pipe(Effect3.asVoid);
+      },
       runTask: (config) => makeTaskRunner(stream, "task", taskRunnerRuntime, {
         ...config,
         triggerName: config.triggerName ?? triggerName
@@ -551,7 +636,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             yield* runtime.setState(next);
           })
         )
-      ).pipe(Effect3.catchAllCause((cause) => Effect3.logError("Flow error", cause))),
+      ).pipe(Effect3.catchCause((cause) => Effect3.logError("Flow error", cause))),
       mutate: (reducer) => Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
@@ -572,7 +657,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             updateDraft(nextState);
           })
         )
-      ).pipe(Effect3.catchAllCause((cause) => Effect3.logError("Flow error", cause)))
+      ).pipe(Effect3.catchCause((cause) => Effect3.logError("Flow error", cause)))
     };
     const pipe = function() {
       const fns = arguments;
@@ -603,12 +688,10 @@ function make2(shape, runtime, options) {
   const flowApi = make(runtime, runtimeInternals);
   const makeIntentBuilder = (runtime_) => LogicBuilderFactory(runtime_, runtimeInternals);
   const withLifecycle = (available, missing) => Effect3.serviceOption(LifecycleContext).pipe(
-    Effect3.flatMap(
-      (maybe) => Option.match(maybe, {
-        onSome: available,
-        onNone: missing
-      })
-    )
+    Effect3.flatMap((maybe) => Option.match(maybe, {
+      onSome: available,
+      onNone: missing
+    }))
   );
   const withPlatform = (invoke) => Effect3.serviceOption(Tag).pipe(
     Effect3.flatMap(
@@ -627,14 +710,29 @@ function make2(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(Effect3.orDie);
   const createIntentBuilder = (stream, triggerName) => makeIntentBuilder(runtime)(stream, triggerName);
+  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(Stream.filter((action) => actionMatchesTag(action, tag)));
+  };
   const onceInRunSession = (key) => Effect3.serviceOption(RunSessionTag).pipe(
     Effect3.map((maybe) => 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 && Context3.isTag(value.tag)
+    value && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value && ServiceMap3.isKey(value.tag)
   );
   const buildModuleHandle = (tag, rt) => {
     const actionsProxy = new Proxy(
@@ -746,44 +844,161 @@ function make2(shape, runtime, options) {
     err.name = "MissingModuleRuntimeError";
     return yield* Effect3.die(err);
   });
-  const stateApi = {
-    read: runtime.getState,
-    update: (f) => Effect3.gen(function* () {
-      const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
-      if (inTxn) {
-        const prev = yield* runtime.getState;
-        return yield* runtime.setState(f(prev));
-      }
-      const body = () => Effect3.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
-      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "update" }, body) : body();
-    }),
-    mutate: (f) => Effect3.gen(function* () {
-      const recordPatch = runtimeInternals?.txn.recordStatePatch;
-      const updateDraft = runtimeInternals?.txn.updateDraft;
-      const inTxn = yield* 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) => Effect3.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 = () => Effect3.uninterruptible(
+      Effect3.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* Effect3.exit(
+              runtimeInternals.txn.runWithStateTransaction(
+                {
+                  kind: "state",
+                  name: originName,
+                  details: { batched: true, count: batch.length }
+                },
+                () => applyBatch(batch).pipe(Effect3.asVoid)
+              )
+            );
+            const outcome = exit._tag === "Success" ? ok : fail(exit.cause);
+            for (let i = 0; i < batch.length; i++) {
+              yield* Deferred.succeed(batch[i].done, outcome);
+            }
+            if (outcome._tag === "failure") {
+              return;
+            }
+          }
+        } finally {
+          inFlight = false;
+        }
+      })
+    );
+    const waitForMicrotask = () => Effect3.promise(
+      () => new Promise((resolve2) => {
+        if (typeof queueMicrotask === "function") {
+          queueMicrotask(resolve2);
+          return;
+        }
+        Promise.resolve().then(resolve2);
+      })
+    );
+    const enqueueAndAwait = (req) => Effect3.gen(function* () {
+      pending.push(req);
+      if (!inFlight) {
+        yield* waitForMicrotask();
       }
-      const body = () => Effect3.gen(function* () {
-        const prev = yield* runtime.getState;
-        const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
-          f(draft);
+      yield* flushInFlight();
+      const outcome = yield* Deferred.await(req.done);
+      if (outcome._tag === "failure") {
+        return yield* Effect3.die(outcome.cause);
+      }
+    });
+    const coordinator = {
+      enqueueUpdate: (update) => Effect3.gen(function* () {
+        const done = yield* Deferred.make();
+        yield* enqueueAndAwait({ kind: "update", update, done });
+      }),
+      enqueueMutate: (mutate) => Effect3.gen(function* () {
+        const done = yield* Deferred.make();
+        yield* enqueueAndAwait({ kind: "mutate", mutate, done });
+      })
+    };
+    batchedStateWritebackCoordinator = coordinator;
+    return coordinator;
+  };
+  const stateApi = {
+    read: runtime.getState,
+    update: (f) => markDirectStateWriteEffect(
+      Effect3.gen(function* () {
+        const inTxn = yield* Effect3.service(inSyncTransactionFiber).pipe(Effect3.orDie);
+        if (inTxn) {
+          const prev = yield* runtime.getState;
+          return yield* runtime.setState(f(prev));
+        }
+        const body = () => Effect3.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(
+      Effect3.gen(function* () {
+        const recordPatch = runtimeInternals?.txn.recordStatePatch;
+        const updateDraft = runtimeInternals?.txn.updateDraft;
+        const inTxn = yield* Effect3.service(inSyncTransactionFiber).pipe(Effect3.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 = () => Effect3.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;
@@ -827,7 +1042,7 @@ function make2(shape, runtime, options) {
   };
   const effect = (token, handler) => Effect3.gen(function* () {
     if (!isActionToken(token)) {
-      return yield* Effect3.dieMessage("[BoundApi.effect] token must be an ActionToken");
+      return yield* Effect3.die(new Error("[BoundApi.effect] token must be an ActionToken"));
     }
     const phase = getCurrentPhase();
     const logicUnit = options?.logicUnit;
@@ -956,8 +1171,8 @@ function make2(shape, runtime, options) {
             return yield* Effect3.void;
           }
           const force = options2?.force === true;
-          const runHandler = (state) => force ? Effect3.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
-          const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+          const runHandler = (state) => force ? Effect3.provideService(handler(state), forceSourceRefresh, true) : handler(state);
+          const inTxn = yield* Effect3.service(inSyncTransactionFiber).pipe(Effect3.orDie);
           if (inTxn) {
             const state = yield* runtime.getState;
             return yield* runHandler(state);
@@ -989,9 +1204,10 @@ function make2(shape, runtime, options) {
             Effect3.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
             Effect3.map((rt) => buildModuleHandle(tag, rt))
           );
-          const detectAndSelect = FiberRef.get(currentDiagnosticsLevel).pipe(
-            Effect3.tap((level) => {
+          const detectAndSelect = Effect3.service(currentDiagnosticsLevel).pipe(
+            Effect3.map((level) => {
               cachedDiagnosticsLevel = level;
+              return level;
             }),
             Effect3.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
           );
@@ -1005,14 +1221,14 @@ function make2(shape, runtime, options) {
             return detectAndSelect;
           });
         }
-        if (Context3.isTag(arg)) {
+        if (ServiceMap3.isKey(arg)) {
           const candidate = arg;
           if (candidate._kind === "ModuleTag") {
             return resolveModuleRuntime(arg).pipe(
               Effect3.map((rt) => buildModuleHandle(arg, rt))
             );
           }
-          return arg;
+          return Effect3.service(arg).pipe(Effect3.orDie);
         }
         return Effect3.die("BoundApi.use: unsupported argument");
       }
@@ -1024,39 +1240,33 @@ function make2(shape, runtime, options) {
         const arg = args[0];
         if (isActionToken(arg)) {
           const tag = arg.tag;
+          return createIntentBuilder(actionStreamByTag(tag).pipe(Stream.map((action) => action.payload)), tag);
+        }
+        if (Schema.isSchema(arg)) {
+          const decode = Schema.decodeUnknownSync(arg);
           return createIntentBuilder(
             runtime.actions$.pipe(
-              Stream.filter((a) => a._tag === tag || a.type === tag),
-              Stream.map((a) => a.payload)
-            ),
-            tag
+              Stream.filter((a) => {
+                try {
+                  decode(a);
+                  return true;
+                } catch {
+                  return false;
+                }
+              })
+            )
           );
         }
         if (typeof arg === "function") {
           return createIntentBuilder(runtime.actions$.pipe(Stream.filter(arg)));
         }
         if (typeof arg === "string") {
-          return createIntentBuilder(
-            runtime.actions$.pipe(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(Stream.filter((a) => a._tag === arg._tag)),
-              String(arg._tag)
-            );
-          }
-          if (Schema.isSchema(arg)) {
-            return createIntentBuilder(
-              runtime.actions$.pipe(
-                Stream.filter((a) => {
-                  const result = Schema.decodeUnknownSync(arg)(a);
-                  return !!result;
-                })
-              )
-            );
+            const tag = String(arg._tag);
+            return createIntentBuilder(actionStreamByTag(tag), tag);
           }
         }
         return createIntentBuilder(runtime.actions$);
@@ -1064,10 +1274,7 @@ function make2(shape, runtime, options) {
       get: (_target, prop) => {
         guardRunOnly("use_in_setup", "$.onAction");
         if (typeof prop === "string") {
-          return createIntentBuilder(
-            runtime.actions$.pipe(Stream.filter((a) => a._tag === prop || a.type === prop)),
-            prop
-          );
+          return createIntentBuilder(actionStreamByTag(prop), prop);
         }
         return void 0;
       }
@@ -1096,4 +1303,4 @@ export {
   emitInvalidPhaseDiagnosticIfNeeded,
   make2 as make
 };
-//# sourceMappingURL=chunk-BE3HW4FY.js.map
+//# sourceMappingURL=chunk-ZBBMZMA6.js.map