@logixjs/core 0.0.1 → 0.0.2

package/dist/Bound.cjs

@@ -25,16 +25,16 @@ __export(Bound_exports, {
 module.exports = __toCommonJS(Bound_exports);
 
 // src/internal/runtime/core/BoundApiRuntime.ts
-var import_effect16 = require("effect");
+var import_effect19 = 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_effect9 = 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
@@ -78,7 +78,7 @@ var runWithMiddleware = (op, stack) => {
   });
 };
 
-// src/internal/runtime/core/DebugSink.ts
+// src/internal/runtime/core/DebugSink.record.ts
 var currentDebugSinks = import_effect4.FiberRef.unsafeMake([]);
 var currentRuntimeLabel = import_effect4.FiberRef.unsafeMake(void 0);
 var currentTxnId = import_effect4.FiberRef.unsafeMake(void 0);
@@ -330,7 +330,441 @@ var record = (event) => import_effect4.Effect.gen(function* () {
 });
 
 // src/internal/runtime/core/env.ts
+var import_effect8 = require("effect");
+
+// src/internal/runtime/core/HostScheduler.ts
+var noopCancel = () => {
+};
+var safeNowMs = () => {
+  const perf = globalThis.performance;
+  if (perf && typeof perf.now === "function") {
+    try {
+      const v = perf.now();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+    } catch {
+    }
+  }
+  return Date.now();
+};
+var safeQueueMicrotask = (cb) => {
+  const qm = globalThis.queueMicrotask;
+  if (typeof qm === "function") {
+    try {
+      qm(cb);
+      return;
+    } catch {
+    }
+  }
+  try {
+    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 makeRuntimeStore = () => {
+  let tickSeq = 0;
+  const moduleStates = /* @__PURE__ */ new Map();
+  const topicVersions = /* @__PURE__ */ new Map();
+  const topicPriorities = /* @__PURE__ */ new Map();
+  const listenersByTopic = /* @__PURE__ */ new Map();
+  const subscriberCountByModule = /* @__PURE__ */ new Map();
+  const getTopicVersion = (topicKey) => topicVersions.get(topicKey) ?? 0;
+  const getTopicPriority = (topicKey) => topicPriorities.get(topicKey) ?? "normal";
+  const commitTopicBump = (topicKey, priority) => {
+    const prev = topicVersions.get(topicKey) ?? 0;
+    topicVersions.set(topicKey, prev + 1);
+    topicPriorities.set(topicKey, priority);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const set = existing ?? /* @__PURE__ */ new Set();
+    const alreadyHas = set.has(listener);
+    if (!alreadyHas) {
+      set.add(listener);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, set);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const current = listenersByTopic.get(topicKey);
+      if (!current) return;
+      const deleted = current.delete(listener);
+      if (deleted && info) {
+        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          subscriberCountByModule.delete(info.moduleInstanceKey);
+        } else {
+          subscriberCountByModule.set(info.moduleInstanceKey, next);
+        }
+      }
+      if (current.size === 0) {
+        listenersByTopic.delete(topicKey);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.size ?? 0;
+  const getModuleSubscriberCount = (moduleInstanceKey) => subscriberCountByModule.get(moduleInstanceKey) ?? 0;
+  const registerModuleInstance = (args) => {
+    moduleStates.set(args.moduleInstanceKey, args.initialState);
+    if (!topicVersions.has(args.moduleInstanceKey)) {
+      topicVersions.set(args.moduleInstanceKey, 0);
+      topicPriorities.set(args.moduleInstanceKey, "normal");
+    }
+  };
+  const unregisterModuleInstance = (moduleInstanceKey) => {
+    moduleStates.delete(moduleInstanceKey);
+  };
+  const commitTick = (args) => {
+    tickSeq = args.tickSeq;
+    for (const [key, commit] of args.accepted.modules) {
+      moduleStates.set(key, commit.state);
+    }
+    const changedTopics = /* @__PURE__ */ new Map();
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const listeners = Array.from(listenersByTopic.get(topicKey) ?? []);
+      if (listeners.length > 0) {
+        changedTopics.set(topicKey, { priority, listeners });
+      }
+    }
+    return { changedTopics };
+  };
+  const getModuleState = (moduleInstanceKey) => moduleStates.get(moduleInstanceKey);
+  const dispose = () => {
+    moduleStates.clear();
+    topicVersions.clear();
+    topicPriorities.clear();
+    listenersByTopic.clear();
+    subscriberCountByModule.clear();
+  };
+  return {
+    getTickSeq: () => tickSeq,
+    getModuleState,
+    getTopicVersion,
+    getTopicPriority,
+    subscribeTopic,
+    getTopicSubscriberCount,
+    getModuleSubscriberCount,
+    registerModuleInstance,
+    unregisterModuleInstance,
+    commitTick,
+    dispose
+  };
+};
+
+// src/internal/runtime/core/TickScheduler.ts
+var import_effect6 = require("effect");
+
+// src/internal/runtime/core/DevtoolsHub.ts
 var import_effect5 = require("effect");
+var lastRunTs = 0;
+var lastRunTsSeq = 0;
+var nextRunId = () => {
+  const ts = Date.now();
+  if (ts === lastRunTs) {
+    lastRunTsSeq += 1;
+  } else {
+    lastRunTs = ts;
+    lastRunTsSeq = 0;
+  }
+  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
+};
+var currentRunId = nextRunId();
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect7 = require("effect");
+var makeDeclarativeLinkRuntime = () => {
+  const moduleAsSourceById = /* @__PURE__ */ new Map();
+  const moduleAsSourceIdsBySource = /* @__PURE__ */ new Map();
+  const declarativeById = /* @__PURE__ */ new Map();
+  const declarativeReadNodesBySource = /* @__PURE__ */ new Map();
+  const registerModuleAsSourceLink = (link) => {
+    const stored = {
+      ...link,
+      hasValue: false,
+      lastValue: void 0
+    };
+    moduleAsSourceById.set(link.id, stored);
+    const set = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey) ?? /* @__PURE__ */ new Set();
+    set.add(link.id);
+    moduleAsSourceIdsBySource.set(link.sourceModuleInstanceKey, set);
+    return () => {
+      moduleAsSourceById.delete(link.id);
+      const current = moduleAsSourceIdsBySource.get(link.sourceModuleInstanceKey);
+      if (!current) return;
+      current.delete(link.id);
+      if (current.size === 0) {
+        moduleAsSourceIdsBySource.delete(link.sourceModuleInstanceKey);
+      }
+    };
+  };
+  const registerDeclarativeLink = (link) => {
+    const readNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.readNodes) {
+      readNodeById.set(n.nodeId, n);
+    }
+    const dispatchNodeById = /* @__PURE__ */ new Map();
+    for (const n of link.dispatchNodes) {
+      dispatchNodeById.set(n.nodeId, n);
+    }
+    const incomingByDispatch = /* @__PURE__ */ new Map();
+    for (const e of link.ir.edges) {
+      const to = e.to;
+      const isDispatch = dispatchNodeById.has(to);
+      if (!isDispatch) continue;
+      incomingByDispatch.set(to, (incomingByDispatch.get(to) ?? 0) + 1);
+      const count = incomingByDispatch.get(to) ?? 0;
+      if (count > 1) {
+        throw new Error(
+          `[DeclarativeLinkRuntime] Invalid DeclarativeLinkIR: dispatch node has multiple incoming edges (linkId=${link.linkId}, nodeId=${to}).`
+        );
+      }
+    }
+    const dispatchTargetsByReadNode = /* @__PURE__ */ new Map();
+    for (const e of link.ir.edges) {
+      const from = e.from;
+      const to = e.to;
+      if (!readNodeById.has(from)) continue;
+      if (!dispatchNodeById.has(to)) continue;
+      const list = dispatchTargetsByReadNode.get(from) ?? [];
+      list.push(to);
+      dispatchTargetsByReadNode.set(from, list);
+    }
+    const stored = {
+      ...link,
+      readNodeById,
+      dispatchNodeById,
+      dispatchTargetsByReadNode,
+      readNodeState: /* @__PURE__ */ new Map()
+    };
+    declarativeById.set(link.linkId, stored);
+    for (const n of link.readNodes) {
+      const list = declarativeReadNodesBySource.get(n.moduleInstanceKey) ?? [];
+      list.push({ linkId: link.linkId, nodeId: n.nodeId });
+      declarativeReadNodesBySource.set(n.moduleInstanceKey, list);
+    }
+    return () => {
+      declarativeById.delete(link.linkId);
+      for (const n of link.readNodes) {
+        const list = declarativeReadNodesBySource.get(n.moduleInstanceKey);
+        if (!list) continue;
+        const next = list.filter((x) => !(x.linkId === link.linkId && x.nodeId === n.nodeId));
+        if (next.length === 0) {
+          declarativeReadNodesBySource.delete(n.moduleInstanceKey);
+        } else {
+          declarativeReadNodesBySource.set(n.moduleInstanceKey, next);
+        }
+      }
+    };
+  };
+  const applyForSources = (args) => import_effect7.Effect.gen(function* () {
+    let scheduled = false;
+    for (const sourceKey of args.changedModuleInstanceKeys) {
+      const ids = moduleAsSourceIdsBySource.get(sourceKey);
+      if (!ids || ids.size === 0) continue;
+      const 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 +774,45 @@ var getNodeEnv = () => {
   }
 };
 var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+var StateTransactionConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
 };
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var ReplayModeConfigTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ReplayModeConfig")() {
 };
-var ReplayModeConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var StateTransactionOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
 };
-var StateTransactionOverridesTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var ConcurrencyPolicyTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect8.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
 };
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var RuntimeStoreTag = class extends import_effect8.Context.Tag("@logixjs/core/RuntimeStore")() {
+};
+var runtimeStoreLayer = import_effect8.Layer.scoped(
+  RuntimeStoreTag,
+  import_effect8.Effect.acquireRelease(
+    import_effect8.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect8.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect8.Context.Tag("@logixjs/core/HostScheduler")() {
+};
+var hostSchedulerLayer = import_effect8.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect8.Context.Tag("@logixjs/core/DeclarativeLinkRuntime")() {
+};
+var declarativeLinkRuntimeLayer = import_effect8.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect8.Context.Tag("@logixjs/core/TickScheduler")() {
 };
 
 // src/internal/runtime/core/TaskRunner.ts
-var inSyncTransactionFiber = import_effect6.FiberRef.unsafeMake(false);
-var forceSourceRefresh = import_effect6.FiberRef.unsafeMake(false);
+var inSyncTransactionFiber = import_effect9.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect9.FiberRef.unsafeMake(false);
 var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
 var defaultOrigins = (triggerName) => ({
   pending: {
@@ -371,8 +828,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_effect9.Effect.gen(function* () {
+  const inTxn = yield* import_effect9.FiberRef.get(inSyncTransactionFiber);
   if (!inTxn) {
     return false;
   }
@@ -391,8 +848,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_effect9.Effect.map((p) => p.concurrencyLimit)) : import_effect9.Effect.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_effect9.Effect.gen(function* () {
   const noop = yield* shouldNoopInSyncTransactionFiber({
     moduleId: runtime.moduleId,
     instanceId: runtime.instanceId,
@@ -413,12 +870,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_effect9.Effect.uninterruptible(
+      runtime.runWithStateTransaction(origins.pending, () => import_effect9.Effect.asVoid(resolve(pending, payload)))
     );
   }
   const io = resolve(config.effect, payload);
-  const exit = yield* import_effect6.Effect.exit(io);
+  const exit = yield* import_effect9.Effect.exit(io);
   if (getCanWriteBack) {
     const ok = yield* getCanWriteBack;
     if (!ok) {
@@ -428,21 +885,21 @@ var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_eff
   if (exit._tag === "Success") {
     const success = config.success;
     if (success) {
-      yield* runtime.runWithStateTransaction(origins.success, () => import_effect6.Effect.asVoid(success(exit.value, payload)));
+      yield* runtime.runWithStateTransaction(origins.success, () => import_effect9.Effect.asVoid(success(exit.value, payload)));
     }
     return;
   }
   const cause = exit.cause;
-  if (import_effect6.Cause.isInterrupted(cause)) {
+  if (import_effect9.Cause.isInterrupted(cause)) {
     return;
   }
   const failure = config.failure;
   if (failure) {
-    yield* runtime.runWithStateTransaction(origins.failure, () => import_effect6.Effect.asVoid(failure(cause, payload)));
+    yield* runtime.runWithStateTransaction(origins.failure, () => import_effect9.Effect.asVoid(failure(cause, payload)));
   }
 }).pipe(
   // Watchers must not crash as a whole due to a single task failure: swallow errors, but keep them diagnosable.
-  import_effect6.Effect.catchAllCause(
+  import_effect9.Effect.catchAllCause(
     (cause) => record({
       type: "diagnostic",
       moduleId: runtime.moduleId,
@@ -457,35 +914,35 @@ var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_eff
         kind: "task",
         name: config.triggerName
       }
-    }).pipe(import_effect6.Effect.zipRight(import_effect6.Effect.logError("TaskRunner error", cause)))
+    }).pipe(import_effect9.Effect.zipRight(import_effect9.Effect.logError("TaskRunner error", cause)))
   )
 );
 var makeTaskRunner = (stream, mode, runtime, config) => {
   if (mode === "latest") {
-    return import_effect6.Effect.gen(function* () {
-      const taskIdRef = yield* import_effect6.Ref.make(0);
-      const currentFiberRef = yield* import_effect6.Ref.make(void 0);
-      const start = (payload) => import_effect6.Effect.gen(function* () {
-        const taskId = yield* import_effect6.Ref.updateAndGet(taskIdRef, (n) => n + 1);
-        const prev = yield* import_effect6.Ref.get(currentFiberRef);
+    return import_effect9.Effect.gen(function* () {
+      const taskIdRef = yield* import_effect9.Ref.make(0);
+      const currentFiberRef = yield* import_effect9.Ref.make(void 0);
+      const start = (payload) => import_effect9.Effect.gen(function* () {
+        const taskId = yield* import_effect9.Ref.updateAndGet(taskIdRef, (n) => n + 1);
+        const prev = yield* import_effect9.Ref.get(currentFiberRef);
         if (prev) {
-          yield* import_effect6.Fiber.interruptFork(prev);
+          yield* import_effect9.Fiber.interruptFork(prev);
         }
-        const canWriteBack = import_effect6.Ref.get(taskIdRef).pipe(import_effect6.Effect.map((current) => current === taskId));
-        const fiber = yield* import_effect6.Effect.fork(
+        const canWriteBack = import_effect9.Ref.get(taskIdRef).pipe(import_effect9.Effect.map((current) => current === taskId));
+        const fiber = yield* import_effect9.Effect.fork(
           runTaskLifecycle(payload, runtime, config, canWriteBack)
         );
-        yield* import_effect6.Ref.set(currentFiberRef, fiber);
+        yield* import_effect9.Ref.set(currentFiberRef, fiber);
       });
-      return yield* import_effect6.Stream.runForEach(stream, start);
+      return yield* import_effect9.Stream.runForEach(stream, start);
     });
   }
   if (mode === "exhaust") {
-    return import_effect6.Effect.gen(function* () {
+    return import_effect9.Effect.gen(function* () {
       const concurrency = yield* resolveConcurrencyLimit(runtime);
-      const busyRef = yield* import_effect6.Ref.make(false);
-      const mapper = (payload) => import_effect6.Effect.gen(function* () {
-        const acquired = yield* import_effect6.Ref.modify(
+      const busyRef = yield* import_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]
         );
@@ -495,25 +952,25 @@ var makeTaskRunner = (stream, mode, runtime, config) => {
         try {
           yield* runTaskLifecycle(payload, runtime, config);
         } finally {
-          yield* import_effect6.Ref.set(busyRef, false);
+          yield* import_effect9.Ref.set(busyRef, false);
         }
       });
-      return yield* import_effect6.Stream.runDrain(stream.pipe(import_effect6.Stream.mapEffect(mapper, { concurrency })));
+      return yield* import_effect9.Stream.runDrain(stream.pipe(import_effect9.Stream.mapEffect(mapper, { concurrency })));
     });
   }
   if (mode === "parallel") {
-    return import_effect6.Effect.gen(function* () {
+    return import_effect9.Effect.gen(function* () {
       const concurrency = yield* resolveConcurrencyLimit(runtime);
-      return yield* import_effect6.Stream.runDrain(
+      return yield* import_effect9.Stream.runDrain(
         stream.pipe(
-          import_effect6.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
+          import_effect9.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
             concurrency
           })
         )
       );
     });
   }
-  return import_effect6.Stream.runForEach(
+  return import_effect9.Stream.runForEach(
     stream,
     (payload) => runTaskLifecycle(payload, runtime, config)
   );
@@ -574,14 +1031,14 @@ var mutateWithPatchPaths = (base, mutator) => {
 };
 
 // src/internal/runtime/core/FlowRuntime.ts
-var import_effect9 = require("effect");
+var import_effect12 = require("effect");
 
 // src/internal/effect-op.ts
-var import_effect8 = require("effect");
+var import_effect11 = 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_effect10 = require("effect");
+var RunSessionTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/RunSession")() {
 };
 var RunSessionTag = RunSessionTagImpl;
 
@@ -617,8 +1074,8 @@ function isReadQuery(input) {
 }
 
 // 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_effect12.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect12.Effect.map((maybe) => import_effect12.Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var getRuntimeScope = (runtime) => {
   if (!runtime) return {};
@@ -632,8 +1089,8 @@ var getRuntimeScope = (runtime) => {
 var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
 var make2 = (runtime, runtimeInternals) => {
   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_effect12.Effect.map((p) => p.concurrencyLimit)) : import_effect12.Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => import_effect12.Effect.gen(function* () {
     const stack = yield* getMiddlewareStack();
     const meta = {
       ...options?.meta ?? {},
@@ -644,8 +1101,8 @@ var make2 = (runtime, runtimeInternals) => {
       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 sessionOpt = yield* import_effect12.Effect.serviceOption(RunSessionTag);
+      if (import_effect12.Option.isSome(sessionOpt)) {
         const key = meta.instanceId ?? "global";
         meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
       }
@@ -660,21 +1117,21 @@ var make2 = (runtime, runtimeInternals) => {
     return yield* run(op, stack);
   });
   const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
-  const runStreamSequential = (eff, options) => (stream) => import_effect9.Stream.runForEach(
+  const runStreamSequential = (eff, options) => (stream) => import_effect12.Stream.runForEach(
     stream,
     (payload) => runAsFlowOp("flow.run", payload, runEffect(eff)(payload), options)
   );
-  const runStreamParallel = (eff, options) => (stream) => import_effect9.Effect.gen(function* () {
+  const runStreamParallel = (eff, options) => (stream) => import_effect12.Effect.gen(function* () {
     const concurrency = yield* resolveConcurrencyLimit2();
-    return yield* import_effect9.Stream.runDrain(
+    return yield* import_effect12.Stream.runDrain(
       stream.pipe(
-        import_effect9.Stream.mapEffect(
+        import_effect12.Stream.mapEffect(
           (payload) => runAsFlowOp("flow.runParallel", payload, runEffect(eff)(payload), options),
           { concurrency }
         )
       )
     ).pipe(
-      import_effect9.Effect.catchAllCause(
+      import_effect12.Effect.catchAllCause(
         (cause) => record({
           type: "diagnostic",
           moduleId: scope.moduleId,
@@ -688,25 +1145,25 @@ var make2 = (runtime, runtimeInternals) => {
             kind: "flow",
             name: "runParallel"
           }
-        }).pipe(import_effect9.Effect.zipRight(import_effect9.Effect.failCause(cause)))
+        }).pipe(import_effect12.Effect.zipRight(import_effect12.Effect.failCause(cause)))
       )
     );
   });
   return {
-    fromAction: (predicate) => runtime.actions$.pipe(import_effect9.Stream.filter(predicate)),
+    fromAction: (predicate) => runtime.actions$.pipe(import_effect12.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, {
+    debounce: (ms) => (stream) => import_effect12.Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => import_effect12.Stream.throttle(stream, {
       cost: () => 1,
       units: 1,
       duration: ms,
       strategy: "enforce"
     }),
-    filter: (predicate) => (stream) => import_effect9.Stream.filter(stream, predicate),
+    filter: (predicate) => (stream) => import_effect12.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(
+    runLatest: (eff, options) => (stream) => import_effect12.Stream.runDrain(
+      import_effect12.Stream.map(
         stream,
         (payload) => runAsFlowOp(
           "flow.runLatest",
@@ -715,16 +1172,16 @@ var make2 = (runtime, runtimeInternals) => {
           options
         )
       ).pipe(
-        import_effect9.Stream.flatMap((effect) => import_effect9.Stream.fromEffect(effect), {
+        import_effect12.Stream.flatMap((effect) => import_effect12.Stream.fromEffect(effect), {
           switch: true
         })
       )
     ),
-    runExhaust: (eff, options) => (stream) => import_effect9.Effect.gen(function* () {
+    runExhaust: (eff, options) => (stream) => import_effect12.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(
+      const busyRef = yield* import_effect12.Ref.make(false);
+      const mapper = (payload) => import_effect12.Effect.gen(function* () {
+        const acquired = yield* import_effect12.Ref.modify(
           busyRef,
           (busy) => busy ? [false, busy] : [true, true]
         );
@@ -739,16 +1196,16 @@ var make2 = (runtime, runtimeInternals) => {
             options
           );
         } finally {
-          yield* import_effect9.Ref.set(busyRef, false);
+          yield* import_effect12.Ref.set(busyRef, false);
         }
       });
-      return yield* import_effect9.Stream.runDrain(stream.pipe(import_effect9.Stream.mapEffect(mapper, { concurrency })));
+      return yield* import_effect12.Stream.runDrain(stream.pipe(import_effect12.Stream.mapEffect(mapper, { concurrency })));
     })
   };
 };
 
 // src/internal/runtime/core/MatchBuilder.ts
-var import_effect10 = require("effect");
+var import_effect13 = require("effect");
 var makeMatch = (value) => {
   let result;
   const chain = {
@@ -767,7 +1224,7 @@ var makeMatch = (value) => {
       if (result) {
         return result;
       }
-      return import_effect10.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
+      return import_effect13.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
     }
   };
   return chain;
@@ -790,24 +1247,24 @@ var makeMatchTag = (value) => {
       if (result) {
         return result;
       }
-      return import_effect10.Effect.dieMessage("[FluentMatchTag] Non-exhaustive match: no tag handler matched value");
+      return import_effect13.Effect.dieMessage("[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_effect14 = require("effect");
+var Tag = import_effect14.Context.GenericTag("@logixjs/Platform");
 
 // src/internal/runtime/core/Lifecycle.ts
-var import_effect12 = require("effect");
-var LifecycleContext = import_effect12.Context.GenericTag("@logixjs/LifecycleManager");
+var import_effect15 = require("effect");
+var LifecycleContext = import_effect15.Context.GenericTag("@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_effect16 = require("effect");
+var LogicPhaseServiceTag = import_effect16.Context.GenericTag("@logixjs/LogicPhaseService");
+var LogicUnitServiceTag = class extends import_effect16.Context.Tag("@logixjs/LogicUnitService")() {
 };
 var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(new Error(`[LogicPhaseError] ${api} is not allowed in ${phase} phase (kind=${kind}).`), {
   _tag: "LogicPhaseError",
@@ -818,11 +1275,11 @@ var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(new Erro
 });
 
 // src/internal/root.ts
-var import_effect15 = require("effect");
+var import_effect18 = 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_effect17 = require("effect");
+var RootContextTagImpl = class extends import_effect17.Context.Tag("@logixjs/core/RootContext")() {
 };
 var RootContextTag = RootContextTagImpl;
 
@@ -857,19 +1314,19 @@ ${extra}` : "",
   err.fix = fix;
   return err;
 };
-var resolve2 = (tag, options) => import_effect15.Effect.gen(function* () {
+var resolve2 = (tag, options) => import_effect18.Effect.gen(function* () {
   const entrypoint = options?.entrypoint ?? "logic.root.resolve";
   const root = yield* RootContextTag;
   const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : void 0);
   if (!rootContext) {
-    return yield* import_effect15.Effect.die(
+    return yield* import_effect18.Effect.die(
       makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
     );
   }
   try {
-    return import_effect15.Context.get(rootContext, tag);
+    return import_effect18.Context.get(rootContext, tag);
   } catch {
-    return yield* import_effect15.Effect.die(makeMissingRootProviderError(tag, entrypoint));
+    return yield* import_effect18.Effect.die(makeMissingRootProviderError(tag, entrypoint));
   }
 });
 
@@ -933,7 +1390,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_effect19.Stream.map(f)), triggerName),
       run(eff, options) {
         return flowApi.run(eff, options)(stream);
       },
@@ -946,8 +1403,8 @@ 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) => import_effect19.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect19.Effect.asVoid),
+      runParallelFork: (eff) => import_effect19.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect19.Effect.asVoid),
       runTask: (config) => makeTaskRunner(stream, "task", taskRunnerRuntime, {
         ...config,
         triggerName: config.triggerName ?? triggerName
@@ -965,20 +1422,20 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
         triggerName: config.triggerName ?? triggerName
       }),
       toStream: () => stream,
-      update: (reducer) => import_effect16.Stream.runForEach(
+      update: (reducer) => import_effect19.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:update",
             name: triggerName
           },
-          () => import_effect16.Effect.gen(function* () {
+          () => import_effect19.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_effect19.Effect.isEffect(next)) {
+              const exit = yield* import_effect19.Effect.exit(next);
               if (exit._tag === "Failure") {
-                yield* import_effect16.Effect.logError("Flow error", exit.cause);
+                yield* import_effect19.Effect.logError("Flow error", exit.cause);
                 return;
               }
               yield* runtime.setState(exit.value);
@@ -987,15 +1444,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_effect19.Effect.catchAllCause((cause) => import_effect19.Effect.logError("Flow error", cause))),
+      mutate: (reducer) => import_effect19.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:mutate",
             name: triggerName
           },
-          () => import_effect16.Effect.gen(function* () {
+          () => import_effect19.Effect.gen(function* () {
             const prev = yield* runtime.getState;
             const recordPatch = runtimeInternals.txn.recordStatePatch;
             const updateDraft = runtimeInternals.txn.updateDraft;
@@ -1008,7 +1465,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             updateDraft(nextState);
           })
         )
-      ).pipe(import_effect16.Effect.catchAllCause((cause) => import_effect16.Effect.logError("Flow error", cause)))
+      ).pipe(import_effect19.Effect.catchAllCause((cause) => import_effect19.Effect.logError("Flow error", cause)))
     };
     const pipe = function() {
       const fns = arguments;
@@ -1038,19 +1495,19 @@ function make3(shape, runtime, options) {
   };
   const flowApi = make2(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, {
+  const withLifecycle = (available, missing) => import_effect19.Effect.serviceOption(LifecycleContext).pipe(
+    import_effect19.Effect.flatMap(
+      (maybe) => import_effect19.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_effect19.Effect.serviceOption(Tag).pipe(
+    import_effect19.Effect.flatMap(
+      (maybe) => import_effect19.Option.match(maybe, {
         onSome: invoke,
-        onNone: () => import_effect16.Effect.void
+        onNone: () => import_effect19.Effect.void
       })
     )
   );
@@ -1065,12 +1522,12 @@ function make3(shape, runtime, options) {
     kind: "lifecycle_in_run"
   });
   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 onceInRunSession = (key) => import_effect19.Effect.serviceOption(RunSessionTag).pipe(
+    import_effect19.Effect.map((maybe) => import_effect19.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_effect19.Context.isTag(value.tag)
   );
   const buildModuleHandle = (tag, rt) => {
     const actionsProxy = new Proxy(
@@ -1083,7 +1540,7 @@ function make3(shape, runtime, options) {
       }
     );
     const handle = {
-      read: (selector) => import_effect16.Effect.map(rt.getState, selector),
+      read: (selector) => import_effect19.Effect.map(rt.getState, selector),
       changes: rt.changes,
       dispatch: rt.dispatch,
       actions$: rt.actions$,
@@ -1093,7 +1550,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_effect19.Effect.gen(function* () {
     if (cachedDiagnosticsLevel === "off") return;
     const key = `module_descriptor:${String(rt.instanceId ?? "unknown")}`;
     const shouldEmit = yield* onceInRunSession(key);
@@ -1133,7 +1590,7 @@ function make3(shape, runtime, options) {
       data
     });
   });
-  const resolveModuleRuntime = (tag) => import_effect16.Effect.gen(function* () {
+  const resolveModuleRuntime = (tag) => import_effect19.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 +1601,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_effect19.Effect.serviceOption(tag);
+      if (import_effect19.Option.isSome(fromEnv)) {
         return fromEnv.value;
       }
     }
@@ -1180,23 +1637,23 @@ function make3(shape, runtime, options) {
     };
     err.fix = fix;
     err.name = "MissingModuleRuntimeError";
-    return yield* import_effect16.Effect.die(err);
+    return yield* import_effect19.Effect.die(err);
   });
   const stateApi = {
     read: runtime.getState,
-    update: (f) => import_effect16.Effect.gen(function* () {
-      const inTxn = yield* import_effect16.FiberRef.get(inSyncTransactionFiber);
+    update: (f) => import_effect19.Effect.gen(function* () {
+      const inTxn = yield* import_effect19.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)));
+      const body = () => import_effect19.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* () {
+    mutate: (f) => import_effect19.Effect.gen(function* () {
       const recordPatch = runtimeInternals?.txn.recordStatePatch;
       const updateDraft = runtimeInternals?.txn.updateDraft;
-      const inTxn = yield* import_effect16.FiberRef.get(inSyncTransactionFiber);
+      const inTxn = yield* import_effect19.FiberRef.get(inSyncTransactionFiber);
       if (inTxn) {
         const prev = yield* runtime.getState;
         const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
@@ -1208,7 +1665,7 @@ function make3(shape, runtime, options) {
         updateDraft?.(nextState);
         return;
       }
-      const body = () => import_effect16.Effect.gen(function* () {
+      const body = () => import_effect19.Effect.gen(function* () {
         const prev = yield* runtime.getState;
         const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
           f(draft);
@@ -1257,13 +1714,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_effect19.Effect.sync(() => {
       runtimeInternals.txn.registerReducer(String(tag), fn);
     });
   };
-  const effect = (token, handler) => import_effect16.Effect.gen(function* () {
+  const effect = (token, handler) => import_effect19.Effect.gen(function* () {
     if (!isActionToken(token)) {
-      return yield* import_effect16.Effect.dieMessage("[BoundApi.effect] token must be an ActionToken");
+      return yield* import_effect19.Effect.dieMessage("[BoundApi.effect] token must be an ActionToken");
     }
     const phase = getCurrentPhase();
     const logicUnit = options?.logicUnit;
@@ -1303,56 +1760,56 @@ function make3(shape, runtime, options) {
           return emitSetupOnlyViolation("$.lifecycle.onInitRequired");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect16.Effect.void;
+        return import_effect19.Effect.void;
       },
       onStart: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onStart");
         }
         runtimeInternals.lifecycle.registerStart(eff);
-        return import_effect16.Effect.void;
+        return import_effect19.Effect.void;
       },
       onInit: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onInit");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect16.Effect.void;
+        return import_effect19.Effect.void;
       },
       onDestroy: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onDestroy");
         }
         runtimeInternals.lifecycle.registerDestroy(eff);
-        return import_effect16.Effect.void;
+        return import_effect19.Effect.void;
       },
       onError: (handler) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onError");
         }
         runtimeInternals.lifecycle.registerOnError(handler);
-        return import_effect16.Effect.void;
+        return import_effect19.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_effect19.Effect.asVoid(eff));
+        return import_effect19.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_effect19.Effect.asVoid(eff));
+        return import_effect19.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_effect19.Effect.asVoid(eff));
+        return import_effect19.Effect.void;
       }
     },
     traits: {
@@ -1386,14 +1843,14 @@ function make3(shape, runtime, options) {
         });
       },
       source: {
-        refresh: (fieldPath, options2) => import_effect16.Effect.gen(function* () {
+        refresh: (fieldPath, options2) => import_effect19.Effect.gen(function* () {
           const handler = runtimeInternals.traits.getSourceRefreshHandler(fieldPath);
           if (!handler) {
-            return yield* import_effect16.Effect.void;
+            return yield* import_effect19.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_effect19.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
+          const inTxn = yield* import_effect19.FiberRef.get(inSyncTransactionFiber);
           if (inTxn) {
             const state = yield* runtime.getState;
             return yield* runHandler(state);
@@ -1403,7 +1860,7 @@ function make3(shape, runtime, options) {
               kind: "source-refresh",
               name: fieldPath
             },
-            () => import_effect16.Effect.gen(function* () {
+            () => import_effect19.Effect.gen(function* () {
               const state = yield* runtime.getState;
               return yield* runHandler(state);
             })
@@ -1420,18 +1877,18 @@ 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_effect19.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_effect19.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
+            import_effect19.Effect.map((rt) => buildModuleHandle(tag, rt))
           );
-          const detectAndSelect = import_effect16.FiberRef.get(currentDiagnosticsLevel).pipe(
-            import_effect16.Effect.tap((level) => {
+          const detectAndSelect = import_effect19.FiberRef.get(currentDiagnosticsLevel).pipe(
+            import_effect19.Effect.tap((level) => {
               cachedDiagnosticsLevel = level;
             }),
-            import_effect16.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
+            import_effect19.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
           );
-          return import_effect16.Effect.suspend(() => {
+          return import_effect19.Effect.suspend(() => {
             if (cachedDiagnosticsLevel === "off") {
               return resolveAndBuild;
             }
@@ -1441,16 +1898,16 @@ function make3(shape, runtime, options) {
             return detectAndSelect;
           });
         }
-        if (import_effect16.Context.isTag(arg)) {
+        if (import_effect19.Context.isTag(arg)) {
           const candidate = arg;
           if (candidate._kind === "ModuleTag") {
             return resolveModuleRuntime(arg).pipe(
-              import_effect16.Effect.map((rt) => buildModuleHandle(arg, rt))
+              import_effect19.Effect.map((rt) => buildModuleHandle(arg, rt))
             );
           }
           return arg;
         }
-        return import_effect16.Effect.die("BoundApi.use: unsupported argument");
+        return import_effect19.Effect.die("BoundApi.use: unsupported argument");
       }
     }),
     onAction: new Proxy(() => {
@@ -1462,33 +1919,33 @@ function make3(shape, runtime, options) {
           const tag = arg.tag;
           return createIntentBuilder(
             runtime.actions$.pipe(
-              import_effect16.Stream.filter((a) => a._tag === tag || a.type === tag),
-              import_effect16.Stream.map((a) => a.payload)
+              import_effect19.Stream.filter((a) => a._tag === tag || a.type === tag),
+              import_effect19.Stream.map((a) => a.payload)
             ),
             tag
           );
         }
         if (typeof arg === "function") {
-          return createIntentBuilder(runtime.actions$.pipe(import_effect16.Stream.filter(arg)));
+          return createIntentBuilder(runtime.actions$.pipe(import_effect19.Stream.filter(arg)));
         }
         if (typeof arg === "string") {
           return createIntentBuilder(
-            runtime.actions$.pipe(import_effect16.Stream.filter((a) => a._tag === arg || a.type === arg)),
+            runtime.actions$.pipe(import_effect19.Stream.filter((a) => a._tag === arg || a.type === arg)),
             arg
           );
         }
         if (typeof arg === "object" && arg !== null) {
           if ("_tag" in arg) {
             return createIntentBuilder(
-              runtime.actions$.pipe(import_effect16.Stream.filter((a) => a._tag === arg._tag)),
+              runtime.actions$.pipe(import_effect19.Stream.filter((a) => a._tag === arg._tag)),
               String(arg._tag)
             );
           }
-          if (import_effect16.Schema.isSchema(arg)) {
+          if (import_effect19.Schema.isSchema(arg)) {
             return createIntentBuilder(
               runtime.actions$.pipe(
-                import_effect16.Stream.filter((a) => {
-                  const result = import_effect16.Schema.decodeUnknownSync(arg)(a);
+                import_effect19.Stream.filter((a) => {
+                  const result = import_effect19.Schema.decodeUnknownSync(arg)(a);
                   return !!result;
                 })
               )
@@ -1501,7 +1958,7 @@ function make3(shape, runtime, options) {
         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)),
+            runtime.actions$.pipe(import_effect19.Stream.filter((a) => a._tag === prop || a.type === prop)),
             prop
           );
         }