@logixjs/core 0.0.1 → 0.0.2

package/dist/Observability.cjs

@@ -162,11 +162,12 @@ var toJsonValueInternal = (input, options, stats, seen, depth) => {
     stats.nonSerializable += 1;
     return truncateString(String(input), options.maxStringLength, stats);
   }
-  const entries = Object.entries(input);
-  const limit = Math.min(entries.length, options.maxObjectKeys);
+  const keys = Object.keys(input).sort();
+  const limit = Math.min(keys.length, options.maxObjectKeys);
   const out = {};
   for (let i = 0; i < limit; i++) {
-    const [rawKey, rawValue] = entries[i];
+    const rawKey = keys[i];
+    const rawValue = input[rawKey];
     const key = truncateString(rawKey, options.maxStringLength, stats);
     if (rawValue === void 0) {
       stats.dropped += 1;
@@ -174,9 +175,9 @@ var toJsonValueInternal = (input, options, stats, seen, depth) => {
     }
     out[key] = toJsonValueInternal(rawValue, options, stats, seen, depth + 1);
   }
-  if (entries.length > limit) {
+  if (keys.length > limit) {
     stats.oversized += 1;
-    out.__truncatedKeys = entries.length - limit;
+    out.__truncatedKeys = keys.length - limit;
   }
   return out;
 };
@@ -304,7 +305,7 @@ var importEvidencePackage = (input) => {
 };
 
 // src/internal/observability/trialRun.ts
-var import_effect33 = require("effect");
+var import_effect36 = require("effect");
 
 // src/internal/observability/evidenceCollector.ts
 var import_effect5 = require("effect");
@@ -396,7 +397,7 @@ var makeEvidenceSink = (session) => {
 };
 var runSessionLayer = (session) => import_effect.Layer.succeed(RunSessionTag, session ?? makeRunSession());
 
-// src/internal/runtime/core/DebugSink.ts
+// src/internal/runtime/core/DebugSink.record.ts
 var import_effect4 = require("effect");
 
 // src/internal/runtime/core/errorSummary.ts
@@ -500,7 +501,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);
@@ -1056,10 +1057,83 @@ var toRuntimeDebugEventRef = (event, options) => {
         meta: metaProjection.value
       });
     }
+    case "warn:priority-inversion": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      } : {
+        tickSeq: e.tickSeq,
+        reason: e.reason,
+        selectorId: e.selectorId
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
+    case "warn:microtask-starvation": {
+      const e = event;
+      const metaInput = isLightLike ? {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      } : {
+        tickSeq: e.tickSeq,
+        microtaskChainDepth: e.microtaskChainDepth
+      };
+      const metaProjection = projectJsonValue(metaInput);
+      options?.onMetaProjection?.({
+        stats: metaProjection.stats,
+        downgrade: metaProjection.downgrade
+      });
+      downgrade = mergeDowngrade2(downgrade, metaProjection.downgrade);
+      return withDowngrade({
+        ...base,
+        kind: "diagnostic",
+        label: e.type,
+        meta: metaProjection.value
+      });
+    }
     default: {
       if (typeof event.type !== "string" || !event.type.startsWith("trace:")) {
         return void 0;
       }
+      if (event.type === "trace:tick") {
+        const data = event.data;
+        const metaInput = isLightLike ? {
+          tickSeq: data?.tickSeq,
+          phase: data?.phase,
+          schedule: data?.schedule,
+          triggerSummary: data?.triggerSummary,
+          anchors: data?.anchors,
+          budget: data?.budget,
+          backlog: data?.backlog,
+          result: data?.result
+        } : {
+          data
+        };
+        const metaProjection2 = projectJsonValue(metaInput);
+        options?.onMetaProjection?.({
+          stats: metaProjection2.stats,
+          downgrade: metaProjection2.downgrade
+        });
+        downgrade = mergeDowngrade2(downgrade, metaProjection2.downgrade);
+        return withDowngrade({
+          ...base,
+          kind: "devtools",
+          label: event.type,
+          meta: metaProjection2.value
+        });
+      }
       if (event.type === "trace:txn-lane") {
         const data = event.data;
         const evidence = data?.evidence ?? data;
@@ -1529,11 +1603,1127 @@ var makeEvidenceCollector = (session) => {
   };
 };
 
-// src/internal/runtime/core/RuntimeKernel.ts
-var import_effect7 = require("effect");
-
+// src/internal/runtime/core/RuntimeKernel.ts
+var import_effect11 = require("effect");
+
+// src/internal/runtime/core/env.ts
+var import_effect10 = 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 makeReadQueryTopicKey = (moduleInstanceKey, selectorId) => `${moduleInstanceKey}::rq:${selectorId}`;
+var parseTopicKey = (topicKey) => {
+  const idx = topicKey.indexOf("::");
+  if (idx <= 0) return void 0;
+  const moduleId = topicKey.slice(0, idx);
+  const rest = topicKey.slice(idx + 2);
+  if (rest.length === 0) return void 0;
+  const idx2 = rest.indexOf("::");
+  if (idx2 < 0) {
+    return { kind: "module", moduleInstanceKey: `${moduleId}::${rest}` };
+  }
+  const instanceId = rest.slice(0, idx2);
+  const suffix = rest.slice(idx2 + 2);
+  if (suffix.startsWith("rq:")) {
+    const selectorId = suffix.slice("rq:".length);
+    if (selectorId.length === 0) return void 0;
+    return {
+      kind: "readQuery",
+      moduleInstanceKey: `${moduleId}::${instanceId}`,
+      selectorId
+    };
+  }
+  return { kind: "module", moduleInstanceKey: `${moduleId}::${instanceId}` };
+};
+var makeRuntimeStore = () => {
+  let tickSeq = 0;
+  const moduleStates = /* @__PURE__ */ new Map();
+  const topicVersions = /* @__PURE__ */ new Map();
+  const topicPriorities = /* @__PURE__ */ new Map();
+  const listenersByTopic = /* @__PURE__ */ new Map();
+  const subscriberCountByModule = /* @__PURE__ */ new Map();
+  const getTopicVersion = (topicKey) => topicVersions.get(topicKey) ?? 0;
+  const getTopicPriority = (topicKey) => topicPriorities.get(topicKey) ?? "normal";
+  const commitTopicBump = (topicKey, priority) => {
+    const prev = topicVersions.get(topicKey) ?? 0;
+    topicVersions.set(topicKey, prev + 1);
+    topicPriorities.set(topicKey, priority);
+  };
+  const subscribeTopic = (topicKey, listener) => {
+    const info = parseTopicKey(topicKey);
+    const existing = listenersByTopic.get(topicKey);
+    const set = existing ?? /* @__PURE__ */ new Set();
+    const alreadyHas = set.has(listener);
+    if (!alreadyHas) {
+      set.add(listener);
+    }
+    if (!existing) {
+      listenersByTopic.set(topicKey, set);
+    }
+    if (!alreadyHas && info) {
+      const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+      subscriberCountByModule.set(info.moduleInstanceKey, prev + 1);
+    }
+    return () => {
+      const current = listenersByTopic.get(topicKey);
+      if (!current) return;
+      const deleted = current.delete(listener);
+      if (deleted && info) {
+        const prev = subscriberCountByModule.get(info.moduleInstanceKey) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          subscriberCountByModule.delete(info.moduleInstanceKey);
+        } else {
+          subscriberCountByModule.set(info.moduleInstanceKey, next);
+        }
+      }
+      if (current.size === 0) {
+        listenersByTopic.delete(topicKey);
+      }
+    };
+  };
+  const getTopicSubscriberCount = (topicKey) => listenersByTopic.get(topicKey)?.size ?? 0;
+  const getModuleSubscriberCount = (moduleInstanceKey) => subscriberCountByModule.get(moduleInstanceKey) ?? 0;
+  const registerModuleInstance = (args) => {
+    moduleStates.set(args.moduleInstanceKey, args.initialState);
+    if (!topicVersions.has(args.moduleInstanceKey)) {
+      topicVersions.set(args.moduleInstanceKey, 0);
+      topicPriorities.set(args.moduleInstanceKey, "normal");
+    }
+  };
+  const unregisterModuleInstance = (moduleInstanceKey) => {
+    moduleStates.delete(moduleInstanceKey);
+  };
+  const commitTick = (args) => {
+    tickSeq = args.tickSeq;
+    for (const [key, commit] of args.accepted.modules) {
+      moduleStates.set(key, commit.state);
+    }
+    const changedTopics = /* @__PURE__ */ new Map();
+    for (const [topicKey, priority] of args.accepted.dirtyTopics) {
+      commitTopicBump(topicKey, priority);
+      const 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_effect8 = require("effect");
+
+// src/internal/runtime/core/DevtoolsHub.ts
+var import_effect6 = 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();
+var devtoolsEnabled = false;
+var isDevtoolsEnabled = () => devtoolsEnabled;
+
+// src/internal/runtime/core/JobQueue.ts
+var maxPriority = (a, b) => a === "normal" || b === "normal" ? "normal" : "low";
+var makeJobQueue = () => {
+  let pendingModules = /* @__PURE__ */ new Map();
+  let pendingDirtyTopics = /* @__PURE__ */ new Map();
+  const hasPending = () => pendingModules.size > 0 || pendingDirtyTopics.size > 0;
+  const enqueueModuleCommit = (commit) => {
+    const prev = pendingModules.get(commit.moduleInstanceKey);
+    if (!prev) {
+      pendingModules.set(commit.moduleInstanceKey, commit);
+      return false;
+    }
+    pendingModules.set(commit.moduleInstanceKey, {
+      ...commit,
+      meta: {
+        ...commit.meta,
+        priority: maxPriority(prev.meta.priority, commit.meta.priority)
+      }
+    });
+    return true;
+  };
+  const markTopicDirty = (topicKey, priority) => {
+    const prev = pendingDirtyTopics.get(topicKey);
+    pendingDirtyTopics.set(topicKey, prev ? maxPriority(prev, priority) : priority);
+    return prev != null;
+  };
+  const drain = () => {
+    if (!hasPending()) return void 0;
+    const drained = {
+      modules: pendingModules,
+      dirtyTopics: pendingDirtyTopics
+    };
+    pendingModules = /* @__PURE__ */ new Map();
+    pendingDirtyTopics = /* @__PURE__ */ new Map();
+    return drained;
+  };
+  const requeue = (drain2) => {
+    for (const [, commit] of drain2.modules) {
+      enqueueModuleCommit(commit);
+    }
+    for (const [k, p] of drain2.dirtyTopics) {
+      markTopicDirty(k, p);
+    }
+  };
+  return {
+    hasPending,
+    enqueueModuleCommit,
+    markTopicDirty,
+    drain,
+    requeue
+  };
+};
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect7 = require("effect");
+var inSyncTransactionFiber = import_effect7.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect7.FiberRef.unsafeMake(false);
+var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var defaultOrigins = (triggerName) => ({
+  pending: {
+    kind: "task:pending",
+    name: triggerName
+  },
+  success: {
+    kind: "service-callback",
+    name: "task:success"
+  },
+  failure: {
+    kind: "service-callback",
+    name: "task:failure"
+  }
+});
+var shouldNoopInSyncTransactionFiber = (options) => import_effect7.Effect.gen(function* () {
+  const inTxn = yield* import_effect7.FiberRef.get(inSyncTransactionFiber);
+  if (!inTxn) {
+    return false;
+  }
+  if (isDevEnv()) {
+    yield* record({
+      type: "diagnostic",
+      moduleId: options.moduleId,
+      instanceId: options.instanceId,
+      code: options.code,
+      severity: options.severity,
+      message: options.message,
+      hint: options.hint,
+      actionTag: options.actionTag,
+      kind: options.kind
+    });
+  }
+  return true;
+});
+var resolveConcurrencyLimit = (runtime) => runtime.resolveConcurrencyPolicy ? runtime.resolveConcurrencyPolicy().pipe(import_effect7.Effect.map((p) => p.concurrencyLimit)) : import_effect7.Effect.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_effect7.Effect.gen(function* () {
+  const noop = yield* shouldNoopInSyncTransactionFiber({
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "logic::invalid_usage",
+    severity: "error",
+    message: "run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
+    hint: "Call run*Task from the run section of a watcher (e.g. $.onAction/$.onState/$.on); do not call it directly inside a reducer / trait.run / synchronous transaction body. For long-lived flows, use a multi-entry pattern (pending \u2192 IO \u2192 writeback).",
+    kind: "run_task_in_transaction"
+  });
+  if (noop) {
+    return;
+  }
+  const defaults = defaultOrigins(config.triggerName);
+  const origins = {
+    pending: config.origin?.pending ?? defaults.pending,
+    success: config.origin?.success ?? defaults.success,
+    failure: config.origin?.failure ?? defaults.failure
+  };
+  const pending = config.pending;
+  if (pending) {
+    yield* import_effect7.Effect.uninterruptible(
+      runtime.runWithStateTransaction(origins.pending, () => import_effect7.Effect.asVoid(resolve(pending, payload)))
+    );
+  }
+  const io = resolve(config.effect, payload);
+  const exit = yield* import_effect7.Effect.exit(io);
+  if (getCanWriteBack) {
+    const ok = yield* getCanWriteBack;
+    if (!ok) {
+      return;
+    }
+  }
+  if (exit._tag === "Success") {
+    const success = config.success;
+    if (success) {
+      yield* runtime.runWithStateTransaction(origins.success, () => import_effect7.Effect.asVoid(success(exit.value, payload)));
+    }
+    return;
+  }
+  const cause = exit.cause;
+  if (import_effect7.Cause.isInterrupted(cause)) {
+    return;
+  }
+  const failure = config.failure;
+  if (failure) {
+    yield* runtime.runWithStateTransaction(origins.failure, () => import_effect7.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_effect7.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_effect7.Effect.zipRight(import_effect7.Effect.logError("TaskRunner error", cause)))
+  )
+);
+var makeTaskRunner = (stream, mode, runtime, config) => {
+  if (mode === "latest") {
+    return import_effect7.Effect.gen(function* () {
+      const taskIdRef = yield* import_effect7.Ref.make(0);
+      const currentFiberRef = yield* import_effect7.Ref.make(void 0);
+      const start = (payload) => import_effect7.Effect.gen(function* () {
+        const taskId = yield* import_effect7.Ref.updateAndGet(taskIdRef, (n) => n + 1);
+        const prev = yield* import_effect7.Ref.get(currentFiberRef);
+        if (prev) {
+          yield* import_effect7.Fiber.interruptFork(prev);
+        }
+        const canWriteBack = import_effect7.Ref.get(taskIdRef).pipe(import_effect7.Effect.map((current) => current === taskId));
+        const fiber = yield* import_effect7.Effect.fork(
+          runTaskLifecycle(payload, runtime, config, canWriteBack)
+        );
+        yield* import_effect7.Ref.set(currentFiberRef, fiber);
+      });
+      return yield* import_effect7.Stream.runForEach(stream, start);
+    });
+  }
+  if (mode === "exhaust") {
+    return import_effect7.Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      const busyRef = yield* import_effect7.Ref.make(false);
+      const mapper = (payload) => import_effect7.Effect.gen(function* () {
+        const acquired = yield* import_effect7.Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runTaskLifecycle(payload, runtime, config);
+        } finally {
+          yield* import_effect7.Ref.set(busyRef, false);
+        }
+      });
+      return yield* import_effect7.Stream.runDrain(stream.pipe(import_effect7.Stream.mapEffect(mapper, { concurrency })));
+    });
+  }
+  if (mode === "parallel") {
+    return import_effect7.Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      return yield* import_effect7.Stream.runDrain(
+        stream.pipe(
+          import_effect7.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
+            concurrency
+          })
+        )
+      );
+    });
+  }
+  return import_effect7.Stream.runForEach(
+    stream,
+    (payload) => runTaskLifecycle(payload, runtime, config)
+  );
+};
+
+// src/internal/runtime/core/TickScheduler.ts
+var batchDepth = 0;
+var batchWaiters = /* @__PURE__ */ new Set();
+var waitForBatchEndIfNeeded = () => batchDepth === 0 ? import_effect8.Effect.void : import_effect8.Effect.async((resume, signal) => {
+  let done = false;
+  const cleanup = () => {
+    if (done) return;
+    done = true;
+    batchWaiters.delete(waiter);
+    try {
+      signal.removeEventListener("abort", onAbort);
+    } catch {
+    }
+  };
+  const onAbort = () => {
+    cleanup();
+  };
+  const waiter = {
+    resolve: () => {
+      cleanup();
+      resume(import_effect8.Effect.void);
+    }
+  };
+  batchWaiters.add(waiter);
+  try {
+    signal.addEventListener("abort", onAbort, { once: true });
+  } catch {
+  }
+});
+var clampSampleRate = (sampleRate) => {
+  if (typeof sampleRate !== "number" || !Number.isFinite(sampleRate)) return 0;
+  if (sampleRate <= 0) return 0;
+  if (sampleRate >= 1) return 1;
+  return sampleRate;
+};
+var shouldSampleTick = (tickSeq, sampleRate) => {
+  if (sampleRate <= 0) return false;
+  if (sampleRate >= 1) return true;
+  const x = tickSeq >>> 0;
+  const h = Math.imul(x ^ 2654435769, 2246822507) >>> 0;
+  return h / 4294967295 < sampleRate;
+};
+var toTriggerKind = (originKind) => {
+  if (originKind === "action") return "dispatch";
+  if (originKind === "trait-external-store") return "externalStore";
+  if (originKind?.includes("timer")) return "timer";
+  return "unknown";
+};
+var toLane = (priority) => priority === "low" ? "nonUrgent" : "urgent";
+var maxPriority2 = (a, b) => a === "normal" || b === "normal" ? "normal" : "low";
+var mergeDrain = (base, next) => {
+  const modules = new Map(base.modules);
+  for (const [k, commit] of next.modules) {
+    const prev = modules.get(k);
+    if (!prev) {
+      modules.set(k, commit);
+    } else {
+      modules.set(k, {
+        ...commit,
+        meta: {
+          ...commit.meta,
+          priority: maxPriority2(prev.meta.priority, commit.meta.priority)
+        }
+      });
+    }
+  }
+  const dirtyTopics = new Map(base.dirtyTopics);
+  for (const [k, p] of next.dirtyTopics) {
+    const prev = dirtyTopics.get(k);
+    dirtyTopics.set(k, prev ? maxPriority2(prev, p) : p);
+  }
+  return { modules, dirtyTopics };
+};
+var emptyDrain = () => ({ modules: /* @__PURE__ */ new Map(), dirtyTopics: /* @__PURE__ */ new Map() });
+var makeTickScheduler = (args) => {
+  const store = args.runtimeStore;
+  const hostScheduler = args.hostScheduler;
+  const declarativeLinks = args.declarativeLinkRuntime;
+  const queue = args.queue ?? makeJobQueue();
+  const config = {
+    maxSteps: args.config?.maxSteps ?? 64,
+    urgentStepCap: args.config?.urgentStepCap ?? 512,
+    maxDrainRounds: args.config?.maxDrainRounds ?? 8,
+    microtaskChainDepthLimit: args.config?.microtaskChainDepthLimit ?? 32
+  };
+  const telemetry = args.config?.telemetry;
+  const telemetrySampleRate = clampSampleRate(telemetry?.sampleRate);
+  let tickSeq = 0;
+  let scheduled = false;
+  let microtaskChainDepth = 0;
+  let nextForcedReason;
+  let coalescedModules = 0;
+  let coalescedTopics = 0;
+  const yieldMicrotask = import_effect8.Effect.async((resume) => {
+    hostScheduler.scheduleMicrotask(() => resume(import_effect8.Effect.void));
+  });
+  const yieldMacrotask = import_effect8.Effect.async((resume, signal) => {
+    const cancel = hostScheduler.scheduleMacrotask(() => resume(import_effect8.Effect.void));
+    try {
+      signal.addEventListener(
+        "abort",
+        () => {
+          cancel();
+        },
+        { once: true }
+      );
+    } catch {
+    }
+  });
+  const scheduleTick = () => import_effect8.Effect.gen(function* () {
+    if (scheduled) return;
+    scheduled = true;
+    const waitedForBatch = batchDepth > 0;
+    const forcedReason = nextForcedReason;
+    nextForcedReason = void 0;
+    const shouldYieldForStarvation = forcedReason == null && microtaskChainDepth >= Math.max(1, config.microtaskChainDepthLimit);
+    const reason = forcedReason ?? (shouldYieldForStarvation ? "microtask_starvation" : void 0);
+    const boundary = reason ? "macrotask" : "microtask";
+    const startedAs = waitedForBatch ? "batch" : boundary;
+    const depthAtSchedule = microtaskChainDepth;
+    yield* import_effect8.Effect.forkDaemon(
+      import_effect8.Effect.locally(inSyncTransactionFiber, false)(
+        import_effect8.Effect.gen(function* () {
+          try {
+            yield* waitForBatchEndIfNeeded();
+            if (boundary === "microtask") {
+              yield* yieldMicrotask;
+              microtaskChainDepth += 1;
+            } else {
+              yield* yieldMacrotask;
+              microtaskChainDepth = 0;
+            }
+            const schedule = {
+              startedAs,
+              microtaskChainDepth: boundary === "macrotask" ? depthAtSchedule : microtaskChainDepth,
+              ...boundary === "macrotask" ? { forcedMacrotask: true, reason: reason ?? "unknown" } : {}
+            };
+            const outcome = yield* flushTick(schedule);
+            if (!outcome.stable) {
+              nextForcedReason = outcome.degradeReason === "budget_steps" ? "budget" : outcome.degradeReason === "cycle_detected" ? "cycle_detected" : "unknown";
+            }
+          } finally {
+            scheduled = false;
+            if (queue.hasPending()) {
+              yield* scheduleTick();
+            } else {
+              microtaskChainDepth = 0;
+            }
+          }
+        })
+      )
+    );
+  });
+  const flushTick = (schedule) => import_effect8.Effect.gen(function* () {
+    if (!queue.hasPending()) {
+      return { stable: true };
+    }
+    tickSeq += 1;
+    const currentTickSeq = tickSeq;
+    const diagnosticsLevel2 = yield* import_effect8.FiberRef.get(currentDiagnosticsLevel);
+    const shouldEmitTrace = isDevtoolsEnabled() && diagnosticsLevel2 !== "off";
+    const captured = {
+      drainRounds: 0,
+      stable: true,
+      accepted: emptyDrain()
+    };
+    while (captured.drainRounds < config.maxDrainRounds) {
+      const drained = queue.drain();
+      if (!drained) break;
+      captured.drainRounds += 1;
+      captured.accepted = mergeDrain(captured.accepted, drained);
+      if (declarativeLinks && drained.modules.size > 0) {
+        const changedModuleInstanceKeys = Array.from(drained.modules.keys());
+        yield* declarativeLinks.applyForSources({
+          tickSeq: currentTickSeq,
+          acceptedModules: captured.accepted.modules,
+          changedModuleInstanceKeys
+        });
+      }
+    }
+    if (queue.hasPending()) {
+      captured.stable = false;
+      captured.degradeReason = "cycle_detected";
+    }
+    const urgentModules = [];
+    const nonUrgentModules = [];
+    for (const commit of captured.accepted.modules.values()) {
+      if (toLane(commit.meta.priority) === "urgent") {
+        urgentModules.push(commit);
+      } else {
+        nonUrgentModules.push(commit);
+      }
+    }
+    const urgentCapExceeded = urgentModules.length > config.urgentStepCap;
+    const urgentAccepted = urgentCapExceeded ? urgentModules.slice(0, config.urgentStepCap) : urgentModules;
+    const urgentDeferred = urgentCapExceeded ? urgentModules.slice(config.urgentStepCap) : [];
+    const nonUrgentBudget = Math.max(0, config.maxSteps);
+    const nonUrgentAccepted = urgentCapExceeded ? [] : nonUrgentModules.slice(0, nonUrgentBudget);
+    const nonUrgentDeferred = urgentCapExceeded ? nonUrgentModules : nonUrgentModules.slice(nonUrgentBudget);
+    if (urgentCapExceeded) {
+      captured.stable = false;
+      captured.degradeReason = "cycle_detected";
+    } else if (nonUrgentDeferred.length > 0) {
+      captured.stable = false;
+      captured.degradeReason = captured.degradeReason ?? "budget_steps";
+    }
+    const acceptedModules = /* @__PURE__ */ new Map();
+    const deferredModules = /* @__PURE__ */ new Map();
+    for (const c of urgentAccepted) acceptedModules.set(c.moduleInstanceKey, c);
+    for (const c of nonUrgentAccepted) acceptedModules.set(c.moduleInstanceKey, c);
+    for (const c of urgentDeferred) deferredModules.set(c.moduleInstanceKey, c);
+    for (const c of nonUrgentDeferred) deferredModules.set(c.moduleInstanceKey, c);
+    const acceptedTopics = /* @__PURE__ */ new Map();
+    const deferredTopics = /* @__PURE__ */ new Map();
+    for (const [topicKey, priority] of captured.accepted.dirtyTopics) {
+      const info = storeTopicToModuleInstanceKey(topicKey);
+      if (!info) continue;
+      if (acceptedModules.has(info)) {
+        acceptedTopics.set(topicKey, priority);
+      } else if (deferredModules.has(info)) {
+        deferredTopics.set(topicKey, priority);
+      } else {
+        acceptedTopics.set(topicKey, priority);
+      }
+    }
+    const acceptedDrain = {
+      modules: acceptedModules,
+      dirtyTopics: acceptedTopics
+    };
+    const deferredDrain = deferredModules.size > 0 || deferredTopics.size > 0 ? {
+      modules: deferredModules,
+      dirtyTopics: deferredTopics
+    } : void 0;
+    captured.deferred = deferredDrain;
+    let startedAtMs;
+    let triggerSummary;
+    let anchor;
+    let backlog;
+    let result;
+    if (shouldEmitTrace) {
+      startedAtMs = Date.now();
+      triggerSummary = (() => {
+        const triggers = Array.from(captured.accepted.modules.values());
+        const counts = /* @__PURE__ */ new Map();
+        let primary = void 0;
+        for (const t of triggers) {
+          const kind = toTriggerKind(t.meta.originKind);
+          counts.set(kind, (counts.get(kind) ?? 0) + 1);
+          if (!primary) {
+            primary = {
+              kind,
+              moduleId: t.moduleId,
+              instanceId: t.instanceId,
+              fieldPath: kind === "externalStore" ? t.meta.originName : void 0,
+              actionTag: kind === "dispatch" ? t.meta.originName : void 0
+            };
+          }
+        }
+        return {
+          total: triggers.length,
+          kinds: Array.from(counts.entries()).map(([kind, count]) => ({ kind, count })),
+          primary,
+          coalescedCount: {
+            modules: coalescedModules,
+            topics: coalescedTopics
+          }
+        };
+      })();
+      anchor = (() => {
+        const first = captured.accepted.modules.values().next().value;
+        if (!first) return void 0;
+        return {
+          moduleId: first.moduleId,
+          instanceId: first.instanceId,
+          txnSeq: first.meta.txnSeq,
+          txnId: first.meta.txnId,
+          ...typeof first.opSeq === "number" ? { opSeq: first.opSeq } : null
+        };
+      })();
+      backlog = (() => {
+        const deferredWork = captured.deferred;
+        if (!deferredWork) return void 0;
+        const pendingDeferredWork = deferredWork.modules.size + deferredWork.dirtyTopics.size;
+        const deferredModulesList = Array.from(deferredWork.modules.values());
+        const pendingExternalInputs = deferredModulesList.filter((m) => toTriggerKind(m.meta.originKind) === "externalStore").length;
+        const primaryDeferred = deferredModulesList.find((m) => toTriggerKind(m.meta.originKind) === "externalStore") ?? deferredModulesList[0];
+        const kind = primaryDeferred ? toTriggerKind(primaryDeferred.meta.originKind) : "unknown";
+        const deferredPrimary = primaryDeferred != null ? {
+          kind: kind === "externalStore" ? "externalStore" : "unknown",
+          moduleId: primaryDeferred.moduleId,
+          instanceId: primaryDeferred.instanceId,
+          fieldPath: kind === "externalStore" ? primaryDeferred.meta.originName : void 0,
+          storeId: void 0
+        } : void 0;
+        return {
+          pendingExternalInputs,
+          pendingDeferredWork,
+          deferredPrimary
+        };
+      })();
+      result = {
+        stable: captured.stable,
+        ...captured.stable ? null : { degradeReason: captured.degradeReason ?? "unknown" }
+      };
+    }
+    if (shouldEmitTrace && schedule.forcedMacrotask && schedule.reason === "microtask_starvation") {
+      yield* record({
+        type: "warn:microtask-starvation",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        tickSeq: currentTickSeq,
+        microtaskChainDepth: schedule.microtaskChainDepth
+      });
+    }
+    if (shouldEmitTrace) {
+      yield* record({
+        type: "trace:tick",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        data: {
+          tickSeq: currentTickSeq,
+          phase: "start",
+          timestampMs: startedAtMs,
+          schedule,
+          triggerSummary,
+          anchors: anchor,
+          budget: {
+            maxSteps: config.maxSteps,
+            elapsedMs: 0,
+            steps: 0,
+            txnCount: acceptedModules.size
+          }
+        }
+      });
+    }
+    if (!captured.stable && shouldEmitTrace) {
+      yield* record({
+        type: "trace:tick",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        data: {
+          tickSeq: currentTickSeq,
+          phase: "budgetExceeded",
+          timestampMs: Date.now(),
+          schedule,
+          triggerSummary,
+          anchors: anchor,
+          budget: {
+            maxSteps: config.maxSteps,
+            elapsedMs: Math.max(0, Date.now() - startedAtMs),
+            steps: config.maxSteps,
+            txnCount: acceptedModules.size
+          },
+          backlog,
+          result
+        }
+      });
+    }
+    if (deferredDrain) {
+      queue.requeue(deferredDrain);
+    }
+    const committed = store.commitTick({
+      tickSeq: currentTickSeq,
+      accepted: acceptedDrain
+    });
+    for (const { listeners } of committed.changedTopics.values()) {
+      for (const listener of listeners) {
+        try {
+          listener();
+        } catch {
+        }
+      }
+    }
+    if (!captured.stable && shouldEmitTrace && backlog?.deferredPrimary) {
+      const primary = backlog.deferredPrimary;
+      if (primary.kind === "externalStore") {
+        const moduleInstanceKey = primary.moduleId && primary.instanceId ? `${primary.moduleId}::${primary.instanceId}` : void 0;
+        if (moduleInstanceKey && store.getModuleSubscriberCount(moduleInstanceKey) > 0) {
+          yield* record({
+            type: "warn:priority-inversion",
+            moduleId: primary.moduleId,
+            instanceId: primary.instanceId,
+            tickSeq: currentTickSeq,
+            reason: "deferredBacklog"
+          });
+        }
+      }
+    }
+    if (shouldEmitTrace) {
+      yield* record({
+        type: "trace:tick",
+        moduleId: anchor?.moduleId,
+        instanceId: anchor?.instanceId,
+        data: {
+          tickSeq: currentTickSeq,
+          phase: "settled",
+          timestampMs: Date.now(),
+          schedule,
+          triggerSummary,
+          anchors: anchor,
+          budget: {
+            maxSteps: config.maxSteps,
+            elapsedMs: Math.max(0, Date.now() - startedAtMs),
+            steps: acceptedModules.size,
+            txnCount: acceptedModules.size
+          },
+          backlog,
+          result
+        }
+      });
+    }
+    if (telemetry?.onTickDegraded && (schedule.forcedMacrotask || !captured.stable) && shouldSampleTick(currentTickSeq, telemetrySampleRate)) {
+      try {
+        telemetry.onTickDegraded({
+          tickSeq: currentTickSeq,
+          stable: captured.stable,
+          degradeReason: captured.stable ? void 0 : captured.degradeReason ?? "unknown",
+          forcedMacrotask: schedule.forcedMacrotask,
+          scheduleReason: schedule.reason,
+          microtaskChainDepth: schedule.microtaskChainDepth,
+          deferredWorkCount: deferredDrain ? deferredDrain.modules.size + deferredDrain.dirtyTopics.size : 0
+        });
+      } catch {
+      }
+    }
+    coalescedModules = 0;
+    coalescedTopics = 0;
+    return { stable: captured.stable, degradeReason: captured.degradeReason };
+  });
+  const flushNow = flushTick({ startedAs: "unknown" }).pipe(import_effect8.Effect.asVoid);
+  const storeTopicToModuleInstanceKey = (topicKey) => {
+    const idx = topicKey.indexOf("::rq:");
+    if (idx > 0) {
+      return topicKey.slice(0, idx);
+    }
+    if (topicKey.includes("::")) {
+      return topicKey;
+    }
+    return void 0;
+  };
+  const onSelectorChanged = ({ moduleInstanceKey, selectorId, priority }) => {
+    const coalesced = queue.markTopicDirty(makeReadQueryTopicKey(moduleInstanceKey, selectorId), priority);
+    if (coalesced) coalescedTopics += 1;
+  };
+  const onModuleCommit = (commit) => import_effect8.Effect.gen(function* () {
+    const coalescedCommit = queue.enqueueModuleCommit(commit);
+    if (coalescedCommit) coalescedModules += 1;
+    const coalescedTopic = queue.markTopicDirty(commit.moduleInstanceKey, commit.meta.priority);
+    if (coalescedTopic) coalescedTopics += 1;
+    yield* scheduleTick();
+  });
+  return {
+    getTickSeq: () => tickSeq,
+    onModuleCommit,
+    onSelectorChanged,
+    flushNow
+  };
+};
+
+// src/internal/runtime/core/DeclarativeLinkRuntime.ts
+var import_effect9 = 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_effect9.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 import_effect6 = require("effect");
 var getNodeEnv = () => {
   try {
     const env = globalThis?.process?.env;
@@ -1543,33 +2733,65 @@ var getNodeEnv = () => {
   }
 };
 var isDevEnv = () => getNodeEnv() !== "production";
-var StateTransactionConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+var StateTransactionConfigTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
 };
 var StateTransactionConfigTag = StateTransactionConfigTagImpl;
-var ReadQueryStrictGateConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
 };
 var ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl;
-var ReplayModeConfigTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+var ReplayModeConfigTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/ReplayModeConfig")() {
 };
-var StateTransactionOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+var StateTransactionOverridesTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
 };
-var ConcurrencyPolicyTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+var ConcurrencyPolicyTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
 };
 var ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl;
-var ConcurrencyPolicyOverridesTagImpl = class extends import_effect6.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect10.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+var RuntimeStoreTag = class extends import_effect10.Context.Tag("@logixjs/core/RuntimeStore")() {
+};
+var runtimeStoreLayer = import_effect10.Layer.scoped(
+  RuntimeStoreTag,
+  import_effect10.Effect.acquireRelease(
+    import_effect10.Effect.sync(() => makeRuntimeStore()),
+    (store) => import_effect10.Effect.sync(() => store.dispose())
+  )
+);
+var HostSchedulerTag = class extends import_effect10.Context.Tag("@logixjs/core/HostScheduler")() {
+};
+var hostSchedulerLayer = import_effect10.Layer.succeed(
+  HostSchedulerTag,
+  getGlobalHostScheduler()
+);
+var DeclarativeLinkRuntimeTag = class extends import_effect10.Context.Tag("@logixjs/core/DeclarativeLinkRuntime")() {
 };
+var declarativeLinkRuntimeLayer = import_effect10.Layer.succeed(
+  DeclarativeLinkRuntimeTag,
+  makeDeclarativeLinkRuntime()
+);
+var TickSchedulerTag = class extends import_effect10.Context.Tag("@logixjs/core/TickScheduler")() {
+};
+var tickSchedulerLayer = (config) => import_effect10.Layer.effect(
+  TickSchedulerTag,
+  import_effect10.Effect.gen(function* () {
+    const store = yield* RuntimeStoreTag;
+    const declarativeLinkRuntime = yield* DeclarativeLinkRuntimeTag;
+    const hostScheduler = yield* HostSchedulerTag;
+    return makeTickScheduler({ runtimeStore: store, declarativeLinkRuntime, hostScheduler, config });
+  })
+);
 
 // src/internal/runtime/core/RuntimeKernel.ts
-var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/RuntimeServicesRuntimeConfig")() {
+var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect11.Context.Tag("@logixjs/core/RuntimeServicesRuntimeConfig")() {
 };
-var RuntimeServicesProviderOverridesTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/RuntimeServicesProviderOverrides")() {
+var RuntimeServicesProviderOverridesTagImpl = class extends import_effect11.Context.Tag("@logixjs/core/RuntimeServicesProviderOverrides")() {
 };
-var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/RuntimeServicesInstanceOverrides")() {
+var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect11.Context.Tag("@logixjs/core/RuntimeServicesInstanceOverrides")() {
 };
 var RuntimeServicesInstanceOverridesTag = RuntimeServicesInstanceOverridesTagImpl;
-var FullCutoverGateModeTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/FullCutoverGateMode")() {
+var FullCutoverGateModeTagImpl = class extends import_effect11.Context.Tag("@logixjs/core/FullCutoverGateMode")() {
 };
-var RuntimeServicesRegistryTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/RuntimeServicesRegistry")() {
+var RuntimeServicesRegistryTagImpl = class extends import_effect11.Context.Tag("@logixjs/core/RuntimeServicesRegistry")() {
 };
 var RUNTIME_SERVICES_EVIDENCE = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeServicesEvidence");
 var formatScope = (moduleId, instanceId) => {
@@ -1604,24 +2826,24 @@ var getRuntimeServicesEvidence = (runtime) => {
 };
 
 // src/internal/runtime/core/ConvergeStaticIrCollector.ts
-var import_effect8 = require("effect");
-var currentConvergeStaticIrCollectors = import_effect8.FiberRef.unsafeMake([]);
-var appendConvergeStaticIrCollectors = (collectors) => import_effect8.Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [
+var import_effect12 = require("effect");
+var currentConvergeStaticIrCollectors = import_effect12.FiberRef.unsafeMake([]);
+var appendConvergeStaticIrCollectors = (collectors) => import_effect12.Layer.fiberRefLocallyScopedWith(currentConvergeStaticIrCollectors, (current) => [
   ...current,
   ...collectors
 ]);
 
 // src/internal/observability/trialRunModule.ts
-var import_effect32 = require("effect");
+var import_effect35 = require("effect");
 
 // src/internal/platform/BuildEnv.ts
-var import_effect11 = require("effect");
+var import_effect15 = require("effect");
 
 // src/internal/platform/ConstructionGuard.ts
-var import_effect9 = require("effect");
+var import_effect13 = require("effect");
 
 // src/internal/platform/RuntimeHost.ts
-var import_effect10 = require("effect");
+var import_effect14 = require("effect");
 var detectKind = () => {
   const isBrowser2 = typeof window !== "undefined" && typeof document !== "undefined";
   if (isBrowser2) return "browser";
@@ -1634,9 +2856,9 @@ var make = (kind) => ({
   isNode: kind === "node",
   isBrowser: kind === "browser"
 });
-var RuntimeHost = class extends import_effect10.Context.Tag("@logixjs/RuntimeHost")() {
+var RuntimeHost = class extends import_effect14.Context.Tag("@logixjs/RuntimeHost")() {
 };
-var layer = (service) => import_effect10.Layer.succeed(RuntimeHost, service);
+var layer = (service) => import_effect14.Layer.succeed(RuntimeHost, service);
 var defaultLayer = layer(make(detectKind()));
 
 // src/internal/platform/BuildEnv.ts
@@ -1647,18 +2869,18 @@ var toConfigProviderFromRecord = (record2) => {
     if (v === void 0) continue;
     map.set(k, String(v));
   }
-  return import_effect11.ConfigProvider.fromMap(map);
+  return import_effect15.ConfigProvider.fromMap(map);
 };
 var layer2 = (options = {}) => {
   const runtimeHost = options.runtimeHost ? layer(options.runtimeHost) : options.runtimeHostKind ? layer(make(options.runtimeHostKind)) : defaultLayer;
   const configProvider = options.configProvider ? options.configProvider : toConfigProviderFromRecord(options.config);
-  const config = import_effect11.Layer.setConfigProvider(configProvider);
-  return import_effect11.Layer.mergeAll(runtimeHost, config);
+  const config = import_effect15.Layer.setConfigProvider(configProvider);
+  return import_effect15.Layer.mergeAll(runtimeHost, config);
 };
 
 // src/internal/runtime/core/KernelRef.ts
-var import_effect12 = require("effect");
-var KernelImplementationRefTagImpl = class extends import_effect12.Context.Tag("@logixjs/core/KernelImplementationRef")() {
+var import_effect16 = require("effect");
+var KernelImplementationRefTagImpl = class extends import_effect16.Context.Tag("@logixjs/core/KernelImplementationRef")() {
 };
 var KERNEL_IMPLEMENTATION_REF = /* @__PURE__ */ Symbol.for("@logixjs/core/kernelImplementationRef");
 var formatScope2 = (moduleId, instanceId) => {
@@ -1683,181 +2905,14 @@ var getKernelImplementationRef = (runtime) => {
 };
 
 // src/internal/runtime/core/runner/ProgramRunner.kernel.ts
-var import_effect26 = require("effect");
+var import_effect29 = require("effect");
 
 // src/internal/runtime/core/BoundApiRuntime.ts
-var import_effect23 = require("effect");
+var import_effect26 = require("effect");
 
 // src/internal/action.ts
-var import_effect13 = require("effect");
-var isActionToken = (value) => typeof value === "function" && value._kind === "ActionToken" && typeof value.tag === "string" && import_effect13.Schema.isSchema(value.schema);
-
-// src/internal/runtime/core/TaskRunner.ts
-var import_effect14 = require("effect");
-var inSyncTransactionFiber = import_effect14.FiberRef.unsafeMake(false);
-var forceSourceRefresh = import_effect14.FiberRef.unsafeMake(false);
-var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
-var defaultOrigins = (triggerName) => ({
-  pending: {
-    kind: "task:pending",
-    name: triggerName
-  },
-  success: {
-    kind: "service-callback",
-    name: "task:success"
-  },
-  failure: {
-    kind: "service-callback",
-    name: "task:failure"
-  }
-});
-var shouldNoopInSyncTransactionFiber = (options) => import_effect14.Effect.gen(function* () {
-  const inTxn = yield* import_effect14.FiberRef.get(inSyncTransactionFiber);
-  if (!inTxn) {
-    return false;
-  }
-  if (isDevEnv()) {
-    yield* record({
-      type: "diagnostic",
-      moduleId: options.moduleId,
-      instanceId: options.instanceId,
-      code: options.code,
-      severity: options.severity,
-      message: options.message,
-      hint: options.hint,
-      actionTag: options.actionTag,
-      kind: options.kind
-    });
-  }
-  return true;
-});
-var resolveConcurrencyLimit = (runtime) => runtime.resolveConcurrencyPolicy ? runtime.resolveConcurrencyPolicy().pipe(import_effect14.Effect.map((p) => p.concurrencyLimit)) : import_effect14.Effect.succeed(16);
-var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_effect14.Effect.gen(function* () {
-  const noop = yield* shouldNoopInSyncTransactionFiber({
-    moduleId: runtime.moduleId,
-    instanceId: runtime.instanceId,
-    code: "logic::invalid_usage",
-    severity: "error",
-    message: "run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
-    hint: "Call run*Task from the run section of a watcher (e.g. $.onAction/$.onState/$.on); do not call it directly inside a reducer / trait.run / synchronous transaction body. For long-lived flows, use a multi-entry pattern (pending \u2192 IO \u2192 writeback).",
-    kind: "run_task_in_transaction"
-  });
-  if (noop) {
-    return;
-  }
-  const defaults = defaultOrigins(config.triggerName);
-  const origins = {
-    pending: config.origin?.pending ?? defaults.pending,
-    success: config.origin?.success ?? defaults.success,
-    failure: config.origin?.failure ?? defaults.failure
-  };
-  const pending = config.pending;
-  if (pending) {
-    yield* import_effect14.Effect.uninterruptible(
-      runtime.runWithStateTransaction(origins.pending, () => import_effect14.Effect.asVoid(resolve(pending, payload)))
-    );
-  }
-  const io = resolve(config.effect, payload);
-  const exit = yield* import_effect14.Effect.exit(io);
-  if (getCanWriteBack) {
-    const ok = yield* getCanWriteBack;
-    if (!ok) {
-      return;
-    }
-  }
-  if (exit._tag === "Success") {
-    const success = config.success;
-    if (success) {
-      yield* runtime.runWithStateTransaction(origins.success, () => import_effect14.Effect.asVoid(success(exit.value, payload)));
-    }
-    return;
-  }
-  const cause = exit.cause;
-  if (import_effect14.Cause.isInterrupted(cause)) {
-    return;
-  }
-  const failure = config.failure;
-  if (failure) {
-    yield* runtime.runWithStateTransaction(origins.failure, () => import_effect14.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_effect14.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_effect14.Effect.zipRight(import_effect14.Effect.logError("TaskRunner error", cause)))
-  )
-);
-var makeTaskRunner = (stream, mode, runtime, config) => {
-  if (mode === "latest") {
-    return import_effect14.Effect.gen(function* () {
-      const taskIdRef = yield* import_effect14.Ref.make(0);
-      const currentFiberRef = yield* import_effect14.Ref.make(void 0);
-      const start = (payload) => import_effect14.Effect.gen(function* () {
-        const taskId = yield* import_effect14.Ref.updateAndGet(taskIdRef, (n) => n + 1);
-        const prev = yield* import_effect14.Ref.get(currentFiberRef);
-        if (prev) {
-          yield* import_effect14.Fiber.interruptFork(prev);
-        }
-        const canWriteBack = import_effect14.Ref.get(taskIdRef).pipe(import_effect14.Effect.map((current) => current === taskId));
-        const fiber = yield* import_effect14.Effect.fork(
-          runTaskLifecycle(payload, runtime, config, canWriteBack)
-        );
-        yield* import_effect14.Ref.set(currentFiberRef, fiber);
-      });
-      return yield* import_effect14.Stream.runForEach(stream, start);
-    });
-  }
-  if (mode === "exhaust") {
-    return import_effect14.Effect.gen(function* () {
-      const concurrency = yield* resolveConcurrencyLimit(runtime);
-      const busyRef = yield* import_effect14.Ref.make(false);
-      const mapper = (payload) => import_effect14.Effect.gen(function* () {
-        const acquired = yield* import_effect14.Ref.modify(
-          busyRef,
-          (busy) => busy ? [false, busy] : [true, true]
-        );
-        if (!acquired) {
-          return;
-        }
-        try {
-          yield* runTaskLifecycle(payload, runtime, config);
-        } finally {
-          yield* import_effect14.Ref.set(busyRef, false);
-        }
-      });
-      return yield* import_effect14.Stream.runDrain(stream.pipe(import_effect14.Stream.mapEffect(mapper, { concurrency })));
-    });
-  }
-  if (mode === "parallel") {
-    return import_effect14.Effect.gen(function* () {
-      const concurrency = yield* resolveConcurrencyLimit(runtime);
-      return yield* import_effect14.Stream.runDrain(
-        stream.pipe(
-          import_effect14.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
-            concurrency
-          })
-        )
-      );
-    });
-  }
-  return import_effect14.Stream.runForEach(
-    stream,
-    (payload) => runTaskLifecycle(payload, runtime, config)
-  );
-};
+var import_effect17 = require("effect");
+var isActionToken = (value) => typeof value === "function" && value._kind === "ActionToken" && typeof value.tag === "string" && import_effect17.Schema.isSchema(value.schema);
 
 // src/internal/runtime/core/mutativePatches.ts
 var import_mutative = require("mutative");
@@ -1963,10 +3018,10 @@ var mutateWithPatchPaths = (base, mutator) => {
 };
 
 // src/internal/runtime/core/FlowRuntime.ts
-var import_effect16 = require("effect");
+var import_effect19 = require("effect");
 
 // src/internal/effect-op.ts
-var import_effect15 = require("effect");
+var import_effect18 = require("effect");
 var nextGlobalOpSeq = 0;
 var nextOpSeq = () => {
   nextGlobalOpSeq += 1;
@@ -2002,7 +3057,7 @@ var stableStringify = (value) => {
   }
   if (t === "object") {
     const record2 = value;
-    const keys = Object.keys(record2).sort((a, b) => a.localeCompare(b));
+    const keys = Object.keys(record2).sort();
     return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record2[k])}`).join(",")}}`;
   }
   return "null";
@@ -2024,8 +3079,8 @@ function isReadQuery(input) {
 }
 
 // src/internal/runtime/core/FlowRuntime.ts
-var getMiddlewareStack = () => import_effect16.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
-  import_effect16.Effect.map((maybe) => import_effect16.Option.isSome(maybe) ? maybe.value.stack : [])
+var getMiddlewareStack = () => import_effect19.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect19.Effect.map((maybe) => import_effect19.Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var getRuntimeScope = (runtime) => {
   if (!runtime) return {};
@@ -2039,8 +3094,8 @@ var getRuntimeScope = (runtime) => {
 var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
 var make3 = (runtime, runtimeInternals) => {
   const scope = getRuntimeScope(runtime);
-  const resolveConcurrencyLimit2 = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect16.Effect.map((p) => p.concurrencyLimit)) : import_effect16.Effect.succeed(16);
-  const runAsFlowOp = (name, payload, eff, options) => import_effect16.Effect.gen(function* () {
+  const resolveConcurrencyLimit2 = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect19.Effect.map((p) => p.concurrencyLimit)) : import_effect19.Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => import_effect19.Effect.gen(function* () {
     const stack = yield* getMiddlewareStack();
     const meta = {
       ...options?.meta ?? {},
@@ -2051,8 +3106,8 @@ var make3 = (runtime, runtimeInternals) => {
       instanceId: scope.instanceId
     };
     if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
-      const sessionOpt = yield* import_effect16.Effect.serviceOption(RunSessionTag);
-      if (import_effect16.Option.isSome(sessionOpt)) {
+      const sessionOpt = yield* import_effect19.Effect.serviceOption(RunSessionTag);
+      if (import_effect19.Option.isSome(sessionOpt)) {
         const key = meta.instanceId ?? "global";
         meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
       }
@@ -2067,21 +3122,21 @@ var make3 = (runtime, runtimeInternals) => {
     return yield* run(op, stack);
   });
   const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
-  const runStreamSequential = (eff, options) => (stream) => import_effect16.Stream.runForEach(
+  const runStreamSequential = (eff, options) => (stream) => import_effect19.Stream.runForEach(
     stream,
     (payload) => runAsFlowOp("flow.run", payload, runEffect(eff)(payload), options)
   );
-  const runStreamParallel = (eff, options) => (stream) => import_effect16.Effect.gen(function* () {
+  const runStreamParallel = (eff, options) => (stream) => import_effect19.Effect.gen(function* () {
     const concurrency = yield* resolveConcurrencyLimit2();
-    return yield* import_effect16.Stream.runDrain(
+    return yield* import_effect19.Stream.runDrain(
       stream.pipe(
-        import_effect16.Stream.mapEffect(
+        import_effect19.Stream.mapEffect(
           (payload) => runAsFlowOp("flow.runParallel", payload, runEffect(eff)(payload), options),
           { concurrency }
         )
       )
     ).pipe(
-      import_effect16.Effect.catchAllCause(
+      import_effect19.Effect.catchAllCause(
         (cause) => record({
           type: "diagnostic",
           moduleId: scope.moduleId,
@@ -2095,25 +3150,25 @@ var make3 = (runtime, runtimeInternals) => {
             kind: "flow",
             name: "runParallel"
           }
-        }).pipe(import_effect16.Effect.zipRight(import_effect16.Effect.failCause(cause)))
+        }).pipe(import_effect19.Effect.zipRight(import_effect19.Effect.failCause(cause)))
       )
     );
   });
   return {
-    fromAction: (predicate) => runtime.actions$.pipe(import_effect16.Stream.filter(predicate)),
+    fromAction: (predicate) => runtime.actions$.pipe(import_effect19.Stream.filter(predicate)),
     fromState: (selectorOrQuery) => runtime.changes(isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),
-    debounce: (ms) => (stream) => import_effect16.Stream.debounce(stream, ms),
-    throttle: (ms) => (stream) => import_effect16.Stream.throttle(stream, {
+    debounce: (ms) => (stream) => import_effect19.Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => import_effect19.Stream.throttle(stream, {
       cost: () => 1,
       units: 1,
       duration: ms,
       strategy: "enforce"
     }),
-    filter: (predicate) => (stream) => import_effect16.Stream.filter(stream, predicate),
+    filter: (predicate) => (stream) => import_effect19.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_effect16.Stream.runDrain(
-      import_effect16.Stream.map(
+    runLatest: (eff, options) => (stream) => import_effect19.Stream.runDrain(
+      import_effect19.Stream.map(
         stream,
         (payload) => runAsFlowOp(
           "flow.runLatest",
@@ -2122,16 +3177,16 @@ var make3 = (runtime, runtimeInternals) => {
           options
         )
       ).pipe(
-        import_effect16.Stream.flatMap((effect) => import_effect16.Stream.fromEffect(effect), {
+        import_effect19.Stream.flatMap((effect) => import_effect19.Stream.fromEffect(effect), {
           switch: true
         })
       )
     ),
-    runExhaust: (eff, options) => (stream) => import_effect16.Effect.gen(function* () {
+    runExhaust: (eff, options) => (stream) => import_effect19.Effect.gen(function* () {
       const concurrency = yield* resolveConcurrencyLimit2();
-      const busyRef = yield* import_effect16.Ref.make(false);
-      const mapper = (payload) => import_effect16.Effect.gen(function* () {
-        const acquired = yield* import_effect16.Ref.modify(
+      const busyRef = yield* import_effect19.Ref.make(false);
+      const mapper = (payload) => import_effect19.Effect.gen(function* () {
+        const acquired = yield* import_effect19.Ref.modify(
           busyRef,
           (busy) => busy ? [false, busy] : [true, true]
         );
@@ -2146,16 +3201,16 @@ var make3 = (runtime, runtimeInternals) => {
             options
           );
         } finally {
-          yield* import_effect16.Ref.set(busyRef, false);
+          yield* import_effect19.Ref.set(busyRef, false);
         }
       });
-      return yield* import_effect16.Stream.runDrain(stream.pipe(import_effect16.Stream.mapEffect(mapper, { concurrency })));
+      return yield* import_effect19.Stream.runDrain(stream.pipe(import_effect19.Stream.mapEffect(mapper, { concurrency })));
     })
   };
 };
 
 // src/internal/runtime/core/MatchBuilder.ts
-var import_effect17 = require("effect");
+var import_effect20 = require("effect");
 var makeMatch = (value) => {
   let result;
   const chain = {
@@ -2174,7 +3229,7 @@ var makeMatch = (value) => {
       if (result) {
         return result;
       }
-      return import_effect17.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
+      return import_effect20.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
     }
   };
   return chain;
@@ -2197,24 +3252,24 @@ var makeMatchTag = (value) => {
       if (result) {
         return result;
       }
-      return import_effect17.Effect.dieMessage("[FluentMatchTag] Non-exhaustive match: no tag handler matched value");
+      return import_effect20.Effect.dieMessage("[FluentMatchTag] Non-exhaustive match: no tag handler matched value");
     }
   };
   return chain;
 };
 
 // src/internal/runtime/core/Platform.ts
-var import_effect18 = require("effect");
-var Tag = import_effect18.Context.GenericTag("@logixjs/Platform");
+var import_effect21 = require("effect");
+var Tag = import_effect21.Context.GenericTag("@logixjs/Platform");
 
 // src/internal/runtime/core/Lifecycle.ts
-var import_effect19 = require("effect");
-var LifecycleContext = import_effect19.Context.GenericTag("@logixjs/LifecycleManager");
+var import_effect22 = require("effect");
+var LifecycleContext = import_effect22.Context.GenericTag("@logixjs/LifecycleManager");
 
 // src/internal/runtime/core/LogicDiagnostics.ts
-var import_effect20 = require("effect");
-var LogicPhaseServiceTag = import_effect20.Context.GenericTag("@logixjs/LogicPhaseService");
-var LogicUnitServiceTag = class extends import_effect20.Context.Tag("@logixjs/LogicUnitService")() {
+var import_effect23 = require("effect");
+var LogicPhaseServiceTag = import_effect23.Context.GenericTag("@logixjs/LogicPhaseService");
+var LogicUnitServiceTag = class extends import_effect23.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",
@@ -2225,11 +3280,11 @@ var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(new Erro
 });
 
 // src/internal/root.ts
-var import_effect22 = require("effect");
+var import_effect25 = require("effect");
 
 // src/internal/runtime/core/RootContext.ts
-var import_effect21 = require("effect");
-var RootContextTagImpl = class extends import_effect21.Context.Tag("@logixjs/core/RootContext")() {
+var import_effect24 = require("effect");
+var RootContextTagImpl = class extends import_effect24.Context.Tag("@logixjs/core/RootContext")() {
 };
 var RootContextTag = RootContextTagImpl;
 
@@ -2264,19 +3319,19 @@ ${extra}` : "",
   err.fix = fix;
   return err;
 };
-var resolve2 = (tag, options) => import_effect22.Effect.gen(function* () {
+var resolve2 = (tag, options) => import_effect25.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_effect22.Effect.die(
+    return yield* import_effect25.Effect.die(
       makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
     );
   }
   try {
-    return import_effect22.Context.get(rootContext, tag);
+    return import_effect25.Context.get(rootContext, tag);
   } catch {
-    return yield* import_effect22.Effect.die(makeMissingRootProviderError(tag, entrypoint));
+    return yield* import_effect25.Effect.die(makeMissingRootProviderError(tag, entrypoint));
   }
 });
 
@@ -2346,7 +3401,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_effect23.Stream.map(f)), triggerName),
+      map: (f) => LogicBuilderFactory(runtime, runtimeInternals)(stream.pipe(import_effect26.Stream.map(f)), triggerName),
       run(eff, options) {
         return flowApi.run(eff, options)(stream);
       },
@@ -2359,8 +3414,8 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
       runParallel(eff, options) {
         return flowApi.runParallel(eff, options)(stream);
       },
-      runFork: (eff) => import_effect23.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect23.Effect.asVoid),
-      runParallelFork: (eff) => import_effect23.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect23.Effect.asVoid),
+      runFork: (eff) => import_effect26.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect26.Effect.asVoid),
+      runParallelFork: (eff) => import_effect26.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect26.Effect.asVoid),
       runTask: (config) => makeTaskRunner(stream, "task", taskRunnerRuntime, {
         ...config,
         triggerName: config.triggerName ?? triggerName
@@ -2378,20 +3433,20 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
         triggerName: config.triggerName ?? triggerName
       }),
       toStream: () => stream,
-      update: (reducer) => import_effect23.Stream.runForEach(
+      update: (reducer) => import_effect26.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:update",
             name: triggerName
           },
-          () => import_effect23.Effect.gen(function* () {
+          () => import_effect26.Effect.gen(function* () {
             const prev = yield* runtime.getState;
             const next = reducer(prev, payload);
-            if (import_effect23.Effect.isEffect(next)) {
-              const exit = yield* import_effect23.Effect.exit(next);
+            if (import_effect26.Effect.isEffect(next)) {
+              const exit = yield* import_effect26.Effect.exit(next);
               if (exit._tag === "Failure") {
-                yield* import_effect23.Effect.logError("Flow error", exit.cause);
+                yield* import_effect26.Effect.logError("Flow error", exit.cause);
                 return;
               }
               yield* runtime.setState(exit.value);
@@ -2400,15 +3455,15 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             yield* runtime.setState(next);
           })
         )
-      ).pipe(import_effect23.Effect.catchAllCause((cause) => import_effect23.Effect.logError("Flow error", cause))),
-      mutate: (reducer) => import_effect23.Stream.runForEach(
+      ).pipe(import_effect26.Effect.catchAllCause((cause) => import_effect26.Effect.logError("Flow error", cause))),
+      mutate: (reducer) => import_effect26.Stream.runForEach(
         stream,
         (payload) => taskRunnerRuntime.runWithStateTransaction(
           {
             kind: "watcher:mutate",
             name: triggerName
           },
-          () => import_effect23.Effect.gen(function* () {
+          () => import_effect26.Effect.gen(function* () {
             const prev = yield* runtime.getState;
             const recordPatch = runtimeInternals.txn.recordStatePatch;
             const updateDraft = runtimeInternals.txn.updateDraft;
@@ -2421,7 +3476,7 @@ var LogicBuilderFactory = (runtime, runtimeInternals) => {
             updateDraft(nextState);
           })
         )
-      ).pipe(import_effect23.Effect.catchAllCause((cause) => import_effect23.Effect.logError("Flow error", cause)))
+      ).pipe(import_effect26.Effect.catchAllCause((cause) => import_effect26.Effect.logError("Flow error", cause)))
     };
     const pipe = function() {
       const fns = arguments;
@@ -2451,19 +3506,19 @@ function make4(shape, runtime, options) {
   };
   const flowApi = make3(runtime, runtimeInternals);
   const makeIntentBuilder = (runtime_) => LogicBuilderFactory(runtime_, runtimeInternals);
-  const withLifecycle = (available, missing) => import_effect23.Effect.serviceOption(LifecycleContext).pipe(
-    import_effect23.Effect.flatMap(
-      (maybe) => import_effect23.Option.match(maybe, {
+  const withLifecycle = (available, missing) => import_effect26.Effect.serviceOption(LifecycleContext).pipe(
+    import_effect26.Effect.flatMap(
+      (maybe) => import_effect26.Option.match(maybe, {
         onSome: available,
         onNone: missing
       })
     )
   );
-  const withPlatform = (invoke) => import_effect23.Effect.serviceOption(Tag).pipe(
-    import_effect23.Effect.flatMap(
-      (maybe) => import_effect23.Option.match(maybe, {
+  const withPlatform = (invoke) => import_effect26.Effect.serviceOption(Tag).pipe(
+    import_effect26.Effect.flatMap(
+      (maybe) => import_effect26.Option.match(maybe, {
         onSome: invoke,
-        onNone: () => import_effect23.Effect.void
+        onNone: () => import_effect26.Effect.void
       })
     )
   );
@@ -2478,12 +3533,12 @@ function make4(shape, runtime, options) {
     kind: "lifecycle_in_run"
   });
   const createIntentBuilder = (stream, triggerName) => makeIntentBuilder(runtime)(stream, triggerName);
-  const onceInRunSession = (key) => import_effect23.Effect.serviceOption(RunSessionTag).pipe(
-    import_effect23.Effect.map((maybe) => import_effect23.Option.isSome(maybe) ? maybe.value.local.once(key) : true)
+  const onceInRunSession = (key) => import_effect26.Effect.serviceOption(RunSessionTag).pipe(
+    import_effect26.Effect.map((maybe) => import_effect26.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_effect23.Context.isTag(value.tag)
+    value && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value && import_effect26.Context.isTag(value.tag)
   );
   const buildModuleHandle = (tag, rt) => {
     const actionsProxy = new Proxy(
@@ -2496,7 +3551,7 @@ function make4(shape, runtime, options) {
       }
     );
     const handle = {
-      read: (selector) => import_effect23.Effect.map(rt.getState, selector),
+      read: (selector) => import_effect26.Effect.map(rt.getState, selector),
       changes: rt.changes,
       dispatch: rt.dispatch,
       actions$: rt.actions$,
@@ -2506,7 +3561,7 @@ function make4(shape, runtime, options) {
     const extend = tag?.[EXTEND_HANDLE];
     return typeof extend === "function" ? extend(rt, handle) ?? handle : handle;
   };
-  const emitModuleDescriptorOnce = (module2, rt) => import_effect23.Effect.gen(function* () {
+  const emitModuleDescriptorOnce = (module2, rt) => import_effect26.Effect.gen(function* () {
     if (cachedDiagnosticsLevel === "off") return;
     const key = `module_descriptor:${String(rt.instanceId ?? "unknown")}`;
     const shouldEmit = yield* onceInRunSession(key);
@@ -2546,7 +3601,7 @@ function make4(shape, runtime, options) {
       data
     });
   });
-  const resolveModuleRuntime = (tag) => import_effect23.Effect.gen(function* () {
+  const resolveModuleRuntime = (tag) => import_effect26.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) {
@@ -2557,8 +3612,8 @@ function make4(shape, runtime, options) {
       return fromImports;
     }
     if (typeof options?.moduleId !== "string") {
-      const fromEnv = yield* import_effect23.Effect.serviceOption(tag);
-      if (import_effect23.Option.isSome(fromEnv)) {
+      const fromEnv = yield* import_effect26.Effect.serviceOption(tag);
+      if (import_effect26.Option.isSome(fromEnv)) {
         return fromEnv.value;
       }
     }
@@ -2593,23 +3648,23 @@ function make4(shape, runtime, options) {
     };
     err.fix = fix;
     err.name = "MissingModuleRuntimeError";
-    return yield* import_effect23.Effect.die(err);
+    return yield* import_effect26.Effect.die(err);
   });
   const stateApi = {
     read: runtime.getState,
-    update: (f) => import_effect23.Effect.gen(function* () {
-      const inTxn = yield* import_effect23.FiberRef.get(inSyncTransactionFiber);
+    update: (f) => import_effect26.Effect.gen(function* () {
+      const inTxn = yield* import_effect26.FiberRef.get(inSyncTransactionFiber);
       if (inTxn) {
         const prev = yield* runtime.getState;
         return yield* runtime.setState(f(prev));
       }
-      const body = () => import_effect23.Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
+      const body = () => import_effect26.Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
       return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "update" }, body) : body();
     }),
-    mutate: (f) => import_effect23.Effect.gen(function* () {
+    mutate: (f) => import_effect26.Effect.gen(function* () {
       const recordPatch = runtimeInternals?.txn.recordStatePatch;
       const updateDraft = runtimeInternals?.txn.updateDraft;
-      const inTxn = yield* import_effect23.FiberRef.get(inSyncTransactionFiber);
+      const inTxn = yield* import_effect26.FiberRef.get(inSyncTransactionFiber);
       if (inTxn) {
         const prev = yield* runtime.getState;
         const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
@@ -2621,7 +3676,7 @@ function make4(shape, runtime, options) {
         updateDraft?.(nextState);
         return;
       }
-      const body = () => import_effect23.Effect.gen(function* () {
+      const body = () => import_effect26.Effect.gen(function* () {
         const prev = yield* runtime.getState;
         const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
           f(draft);
@@ -2670,13 +3725,13 @@ function make4(shape, runtime, options) {
   const matchApi = (value) => makeMatch(value);
   const matchTagApi = (value) => makeMatchTag(value);
   const reducer = (tag, fn) => {
-    return import_effect23.Effect.sync(() => {
+    return import_effect26.Effect.sync(() => {
       runtimeInternals.txn.registerReducer(String(tag), fn);
     });
   };
-  const effect = (token, handler) => import_effect23.Effect.gen(function* () {
+  const effect = (token, handler) => import_effect26.Effect.gen(function* () {
     if (!isActionToken(token)) {
-      return yield* import_effect23.Effect.dieMessage("[BoundApi.effect] token must be an ActionToken");
+      return yield* import_effect26.Effect.dieMessage("[BoundApi.effect] token must be an ActionToken");
     }
     const phase = getCurrentPhase();
     const logicUnit = options?.logicUnit;
@@ -2716,56 +3771,56 @@ function make4(shape, runtime, options) {
           return emitSetupOnlyViolation("$.lifecycle.onInitRequired");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect23.Effect.void;
+        return import_effect26.Effect.void;
       },
       onStart: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onStart");
         }
         runtimeInternals.lifecycle.registerStart(eff);
-        return import_effect23.Effect.void;
+        return import_effect26.Effect.void;
       },
       onInit: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onInit");
         }
         runtimeInternals.lifecycle.registerInitRequired(eff);
-        return import_effect23.Effect.void;
+        return import_effect26.Effect.void;
       },
       onDestroy: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onDestroy");
         }
         runtimeInternals.lifecycle.registerDestroy(eff);
-        return import_effect23.Effect.void;
+        return import_effect26.Effect.void;
       },
       onError: (handler) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onError");
         }
         runtimeInternals.lifecycle.registerOnError(handler);
-        return import_effect23.Effect.void;
+        return import_effect26.Effect.void;
       },
       onSuspend: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onSuspend");
         }
-        runtimeInternals.lifecycle.registerPlatformSuspend(import_effect23.Effect.asVoid(eff));
-        return import_effect23.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformSuspend(import_effect26.Effect.asVoid(eff));
+        return import_effect26.Effect.void;
       },
       onResume: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onResume");
         }
-        runtimeInternals.lifecycle.registerPlatformResume(import_effect23.Effect.asVoid(eff));
-        return import_effect23.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformResume(import_effect26.Effect.asVoid(eff));
+        return import_effect26.Effect.void;
       },
       onReset: (eff) => {
         if (getCurrentPhase() === "run") {
           return emitSetupOnlyViolation("$.lifecycle.onReset");
         }
-        runtimeInternals.lifecycle.registerPlatformReset(import_effect23.Effect.asVoid(eff));
-        return import_effect23.Effect.void;
+        runtimeInternals.lifecycle.registerPlatformReset(import_effect26.Effect.asVoid(eff));
+        return import_effect26.Effect.void;
       }
     },
     traits: {
@@ -2799,14 +3854,14 @@ function make4(shape, runtime, options) {
         });
       },
       source: {
-        refresh: (fieldPath, options2) => import_effect23.Effect.gen(function* () {
+        refresh: (fieldPath, options2) => import_effect26.Effect.gen(function* () {
           const handler = runtimeInternals.traits.getSourceRefreshHandler(fieldPath);
           if (!handler) {
-            return yield* import_effect23.Effect.void;
+            return yield* import_effect26.Effect.void;
           }
           const force = options2?.force === true;
-          const runHandler = (state) => force ? import_effect23.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
-          const inTxn = yield* import_effect23.FiberRef.get(inSyncTransactionFiber);
+          const runHandler = (state) => force ? import_effect26.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
+          const inTxn = yield* import_effect26.FiberRef.get(inSyncTransactionFiber);
           if (inTxn) {
             const state = yield* runtime.getState;
             return yield* runHandler(state);
@@ -2816,7 +3871,7 @@ function make4(shape, runtime, options) {
               kind: "source-refresh",
               name: fieldPath
             },
-            () => import_effect23.Effect.gen(function* () {
+            () => import_effect26.Effect.gen(function* () {
               const state = yield* runtime.getState;
               return yield* runHandler(state);
             })
@@ -2833,18 +3888,18 @@ function make4(shape, runtime, options) {
         if (isModuleLike(arg)) {
           const domain = arg;
           const tag = domain.tag;
-          const resolveAndBuild = resolveModuleRuntime(tag).pipe(import_effect23.Effect.map((rt) => buildModuleHandle(tag, rt)));
+          const resolveAndBuild = resolveModuleRuntime(tag).pipe(import_effect26.Effect.map((rt) => buildModuleHandle(tag, rt)));
           const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(
-            import_effect23.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
-            import_effect23.Effect.map((rt) => buildModuleHandle(tag, rt))
+            import_effect26.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
+            import_effect26.Effect.map((rt) => buildModuleHandle(tag, rt))
           );
-          const detectAndSelect = import_effect23.FiberRef.get(currentDiagnosticsLevel).pipe(
-            import_effect23.Effect.tap((level) => {
+          const detectAndSelect = import_effect26.FiberRef.get(currentDiagnosticsLevel).pipe(
+            import_effect26.Effect.tap((level) => {
               cachedDiagnosticsLevel = level;
             }),
-            import_effect23.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
+            import_effect26.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
           );
-          return import_effect23.Effect.suspend(() => {
+          return import_effect26.Effect.suspend(() => {
             if (cachedDiagnosticsLevel === "off") {
               return resolveAndBuild;
             }
@@ -2854,16 +3909,16 @@ function make4(shape, runtime, options) {
             return detectAndSelect;
           });
         }
-        if (import_effect23.Context.isTag(arg)) {
+        if (import_effect26.Context.isTag(arg)) {
           const candidate = arg;
           if (candidate._kind === "ModuleTag") {
             return resolveModuleRuntime(arg).pipe(
-              import_effect23.Effect.map((rt) => buildModuleHandle(arg, rt))
+              import_effect26.Effect.map((rt) => buildModuleHandle(arg, rt))
             );
           }
           return arg;
         }
-        return import_effect23.Effect.die("BoundApi.use: unsupported argument");
+        return import_effect26.Effect.die("BoundApi.use: unsupported argument");
       }
     }),
     onAction: new Proxy(() => {
@@ -2875,33 +3930,33 @@ function make4(shape, runtime, options) {
           const tag = arg.tag;
           return createIntentBuilder(
             runtime.actions$.pipe(
-              import_effect23.Stream.filter((a) => a._tag === tag || a.type === tag),
-              import_effect23.Stream.map((a) => a.payload)
+              import_effect26.Stream.filter((a) => a._tag === tag || a.type === tag),
+              import_effect26.Stream.map((a) => a.payload)
             ),
             tag
           );
         }
         if (typeof arg === "function") {
-          return createIntentBuilder(runtime.actions$.pipe(import_effect23.Stream.filter(arg)));
+          return createIntentBuilder(runtime.actions$.pipe(import_effect26.Stream.filter(arg)));
         }
         if (typeof arg === "string") {
           return createIntentBuilder(
-            runtime.actions$.pipe(import_effect23.Stream.filter((a) => a._tag === arg || a.type === arg)),
+            runtime.actions$.pipe(import_effect26.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_effect23.Stream.filter((a) => a._tag === arg._tag)),
+              runtime.actions$.pipe(import_effect26.Stream.filter((a) => a._tag === arg._tag)),
               String(arg._tag)
             );
           }
-          if (import_effect23.Schema.isSchema(arg)) {
+          if (import_effect26.Schema.isSchema(arg)) {
             return createIntentBuilder(
               runtime.actions$.pipe(
-                import_effect23.Stream.filter((a) => {
-                  const result = import_effect23.Schema.decodeUnknownSync(arg)(a);
+                import_effect26.Stream.filter((a) => {
+                  const result = import_effect26.Schema.decodeUnknownSync(arg)(a);
                   return !!result;
                 })
               )
@@ -2914,7 +3969,7 @@ function make4(shape, runtime, options) {
         guardRunOnly("use_in_setup", "$.onAction");
         if (typeof prop === "string") {
           return createIntentBuilder(
-            runtime.actions$.pipe(import_effect23.Stream.filter((a) => a._tag === prop || a.type === prop)),
+            runtime.actions$.pipe(import_effect26.Stream.filter((a) => a._tag === prop || a.type === prop)),
             prop
           );
         }
@@ -2935,7 +3990,7 @@ function make4(shape, runtime, options) {
 }
 
 // src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
-var import_effect24 = require("effect");
+var import_effect27 = require("effect");
 
 // src/internal/runtime/core/runner/ProgramRunner.errors.ts
 var summarizeCause = (cause) => {
@@ -3010,17 +4065,22 @@ var DisposeTimeoutError = class extends ProgramRunnerErrorBase {
 
 // src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
 var closeProgramScope = (params) => {
-  return import_effect24.Effect.gen(function* () {
+  return import_effect27.Effect.gen(function* () {
     const start = Date.now();
-    const fiber = yield* import_effect24.Effect.forkDaemon(import_effect24.Scope.close(params.scope, import_effect24.Exit.void));
+    const hostSchedulerOpt = yield* import_effect27.Effect.serviceOption(HostSchedulerTag);
+    const hostScheduler = import_effect27.Option.isSome(hostSchedulerOpt) ? hostSchedulerOpt.value : getGlobalHostScheduler();
+    const yieldMicrotask = import_effect27.Effect.async((resume) => {
+      hostScheduler.scheduleMicrotask(() => resume(import_effect27.Effect.void));
+    });
+    const fiber = yield* import_effect27.Effect.forkDaemon(import_effect27.Scope.close(params.scope, import_effect27.Exit.void));
     while (true) {
-      const exitOpt = yield* import_effect24.Fiber.poll(fiber);
-      if (import_effect24.Option.isSome(exitOpt)) {
+      const exitOpt = yield* import_effect27.Fiber.poll(fiber);
+      if (import_effect27.Option.isSome(exitOpt)) {
         const exit = exitOpt.value;
         if (exit._tag === "Success") {
           return;
         }
-        return yield* import_effect24.Effect.die(new DisposeError(params.identity, exit.cause));
+        return yield* import_effect27.Effect.die(new DisposeError(params.identity, exit.cause));
       }
       const elapsedMs = Date.now() - start;
       if (elapsedMs >= params.timeoutMs) {
@@ -3029,18 +4089,18 @@ var closeProgramScope = (params) => {
           elapsedMs
         });
         if (typeof params.onError === "function") {
-          yield* params.onError(import_effect24.Cause.die(error)).pipe(import_effect24.Effect.catchAllCause(() => import_effect24.Effect.void));
+          yield* params.onError(import_effect27.Cause.die(error)).pipe(import_effect27.Effect.catchAllCause(() => import_effect27.Effect.void));
         }
-        yield* import_effect24.Fiber.interruptFork(fiber);
-        return yield* import_effect24.Effect.die(error);
+        yield* import_effect27.Fiber.interruptFork(fiber);
+        return yield* import_effect27.Effect.die(error);
       }
-      yield* import_effect24.Effect.promise(() => new Promise((r) => queueMicrotask(r)));
+      yield* yieldMicrotask;
     }
   });
 };
 
 // src/internal/runtime/core/runner/ProgramRunner.signals.ts
-var import_effect25 = require("effect");
+var import_effect28 = require("effect");
 var getProcess = () => globalThis.process;
 var isNodeProcess = (value) => typeof value === "object" && value !== null && typeof value.on === "function";
 var removeListener = (proc, event, handler) => {
@@ -3054,24 +4114,24 @@ var removeListener = (proc, event, handler) => {
 };
 var installGracefulShutdownHandlers = (params) => {
   if (!params.enabled) {
-    return import_effect25.Effect.void;
+    return import_effect28.Effect.void;
   }
   const proc = getProcess();
   if (!isNodeProcess(proc)) {
-    return import_effect25.Effect.void;
+    return import_effect28.Effect.void;
   }
   const handler = () => {
-    void import_effect25.Effect.runPromise(import_effect25.Scope.close(params.scope, import_effect25.Exit.void));
+    void import_effect28.Effect.runPromise(import_effect28.Scope.close(params.scope, import_effect28.Exit.void));
   };
-  return import_effect25.Effect.gen(function* () {
-    yield* import_effect25.Scope.addFinalizer(
+  return import_effect28.Effect.gen(function* () {
+    yield* import_effect28.Scope.addFinalizer(
       params.scope,
-      import_effect25.Effect.sync(() => {
+      import_effect28.Effect.sync(() => {
         removeListener(proc, "SIGINT", handler);
         removeListener(proc, "SIGTERM", handler);
       })
     );
-    yield* import_effect25.Effect.sync(() => {
+    yield* import_effect28.Effect.sync(() => {
       proc.on("SIGINT", handler);
       proc.on("SIGTERM", handler);
     });
@@ -3079,14 +4139,14 @@ var installGracefulShutdownHandlers = (params) => {
 };
 
 // src/internal/runtime/core/runner/ProgramRunner.kernel.ts
-var makeProgramRunnerKernel = (makeRuntime, rootImpl, options) => import_effect26.Effect.gen(function* () {
+var makeProgramRunnerKernel = (makeRuntime, rootImpl, options) => import_effect29.Effect.gen(function* () {
   const identity = {
     moduleId: String(rootImpl.module.id),
     instanceId: "unknown"
   };
-  const scope = yield* import_effect26.Scope.make();
+  const scope = yield* import_effect29.Scope.make();
   const runtime = makeRuntime(rootImpl, options);
-  yield* import_effect26.Scope.addFinalizer(scope, import_effect26.Effect.promise(() => runtime.dispose()).pipe(import_effect26.Effect.asVoid));
+  yield* import_effect29.Scope.addFinalizer(scope, import_effect29.Effect.promise(() => runtime.dispose()).pipe(import_effect29.Effect.asVoid));
   const setInstanceId = (value) => {
     identity.instanceId = typeof value === "string" && value.length > 0 ? value : String(value ?? "unknown");
   };
@@ -3115,7 +4175,197 @@ var makeProgramRunnerKernel = (makeRuntime, rootImpl, options) => import_effect2
 });
 
 // src/internal/reflection/manifest.ts
-var import_effect27 = require("effect");
+var import_effect30 = require("effect");
+
+// src/internal/external-store-descriptor.ts
+var EXTERNAL_STORE_DESCRIPTOR = /* @__PURE__ */ Symbol.for("@logixjs/core/externalStoreDescriptor");
+var getExternalStoreDescriptor = (store) => {
+  if (!store || typeof store !== "object" && typeof store !== "function") return void 0;
+  return store[EXTERNAL_STORE_DESCRIPTOR];
+};
+
+// src/internal/state-trait/meta.ts
+var uniqSortedStrings = (input) => {
+  const set = /* @__PURE__ */ new Set();
+  for (const item of input) {
+    const v = item.trim();
+    if (!v) continue;
+    set.add(v);
+  }
+  return Array.from(set).sort();
+};
+var isPlainRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sanitizeJsonValue = (input, depth, stats) => {
+  if (input === null) return null;
+  if (typeof input === "string") return input;
+  if (typeof input === "boolean") return input;
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) {
+      stats.dropped += 1;
+      stats.nonSerializable += 1;
+      stats.nonFiniteNumber += 1;
+      return void 0;
+    }
+    return input;
+  }
+  if (depth >= 6) {
+    stats.dropped += 1;
+    stats.depthExceeded += 1;
+    return void 0;
+  }
+  if (Array.isArray(input)) {
+    const out = [];
+    for (const item of input) {
+      const v = sanitizeJsonValue(item, depth + 1, stats);
+      if (v !== void 0) out.push(v);
+    }
+    return out;
+  }
+  if (isPlainRecord2(input)) {
+    const keys = Object.keys(input).sort();
+    const out = {};
+    for (const key of keys) {
+      const v = sanitizeJsonValue(input[key], depth + 1, stats);
+      if (v !== void 0) out[key] = v;
+    }
+    return out;
+  }
+  stats.dropped += 1;
+  stats.nonSerializable += 1;
+  return void 0;
+};
+var pushSample = (target, value, limit) => {
+  if (target.length >= limit) return;
+  target.push(value);
+};
+var sanitizeWithReport = (input) => {
+  if (input === null || input === void 0) return {};
+  if (typeof input !== "object" || Array.isArray(input)) {
+    return { report: { invalidInput: true } };
+  }
+  const record2 = input;
+  const out = {};
+  const reportUnknownKeys = [];
+  let unknownKeyCount = 0;
+  const reportDroppedKeys = [];
+  let droppedTagItems = 0;
+  const reportIgnoredAnnotationKeys = [];
+  let ignoredAnnotationKeyCount = 0;
+  const reportDroppedAnnotationKeys = [];
+  let droppedAnnotationKeyCount = 0;
+  const stats = { dropped: 0, nonSerializable: 0, depthExceeded: 0, nonFiniteNumber: 0 };
+  const allowed = /* @__PURE__ */ new Set([
+    "label",
+    "description",
+    "group",
+    "docsUrl",
+    "cacheGroup",
+    "canonical",
+    "tags",
+    "annotations"
+  ]);
+  for (const key of Object.keys(record2)) {
+    if (allowed.has(key) || key.startsWith("x-")) continue;
+    unknownKeyCount += 1;
+    pushSample(reportUnknownKeys, key, 8);
+  }
+  const pickString = (key) => {
+    const value = record2[key];
+    if (typeof value !== "string") return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    out[key] = trimmed;
+  };
+  pickString("label");
+  pickString("description");
+  pickString("group");
+  pickString("docsUrl");
+  pickString("cacheGroup");
+  const canonical = record2.canonical;
+  if (canonical !== void 0 && canonical !== null && typeof canonical !== "boolean") {
+    pushSample(reportDroppedKeys, "canonical", 8);
+  } else if (typeof canonical === "boolean") {
+    out.canonical = canonical;
+  }
+  const tagsRaw = record2.tags;
+  if (typeof tagsRaw === "string") {
+    const tags = uniqSortedStrings([tagsRaw]);
+    if (tags.length > 0) out.tags = tags;
+  } else if (Array.isArray(tagsRaw)) {
+    const raw = tagsRaw.filter((x) => typeof x === "string");
+    droppedTagItems += tagsRaw.length - raw.length;
+    const tags = uniqSortedStrings(raw);
+    if (tags.length > 0) out.tags = tags;
+    droppedTagItems += raw.length - tags.length;
+  } else if (tagsRaw !== void 0 && tagsRaw !== null) {
+    pushSample(reportDroppedKeys, "tags", 8);
+  }
+  const annotations = {};
+  const annotationKeys = Object.keys(record2).filter((k) => k.startsWith("x-")).sort();
+  for (const key of annotationKeys) {
+    const v = sanitizeJsonValue(record2[key], 0, stats);
+    if (v !== void 0) {
+      annotations[key] = v;
+    } else {
+      droppedAnnotationKeyCount += 1;
+      pushSample(reportDroppedAnnotationKeys, key, 8);
+    }
+  }
+  const annotationsRaw = record2.annotations;
+  if (annotationsRaw !== void 0 && annotationsRaw !== null && !isPlainRecord2(annotationsRaw)) {
+    pushSample(reportDroppedKeys, "annotations", 8);
+  } else if (isPlainRecord2(annotationsRaw)) {
+    const keys = Object.keys(annotationsRaw).sort();
+    for (const key of keys) {
+      if (!key.startsWith("x-")) {
+        ignoredAnnotationKeyCount += 1;
+        pushSample(reportIgnoredAnnotationKeys, key, 8);
+        continue;
+      }
+      const v = sanitizeJsonValue(annotationsRaw[key], 0, stats);
+      if (v !== void 0) {
+        annotations[key] = v;
+      } else {
+        droppedAnnotationKeyCount += 1;
+        pushSample(reportDroppedAnnotationKeys, key, 8);
+      }
+    }
+  }
+  if (Object.keys(annotations).length > 0) out.annotations = annotations;
+  for (const key of ["label", "description", "group", "docsUrl", "cacheGroup"]) {
+    const value = record2[key];
+    if (value !== void 0 && value !== null && typeof value !== "string") {
+      pushSample(reportDroppedKeys, key, 8);
+    }
+  }
+  const meta = Object.keys(out).length > 0 ? out : void 0;
+  const report = (() => {
+    const hasUnknownKeys = unknownKeyCount > 0;
+    const hasDroppedKeys = reportDroppedKeys.length > 0;
+    const hasDroppedTagItems = droppedTagItems > 0;
+    const hasIgnoredAnnotationKeys = ignoredAnnotationKeyCount > 0;
+    const hasDroppedAnnotations = droppedAnnotationKeyCount > 0 || stats.dropped > 0;
+    if (!hasUnknownKeys && !hasDroppedKeys && !hasDroppedTagItems && !hasIgnoredAnnotationKeys && !hasDroppedAnnotations) {
+      return void 0;
+    }
+    return {
+      ...hasUnknownKeys ? { unknownKeys: reportUnknownKeys, unknownKeyCount } : {},
+      ...hasDroppedKeys ? { droppedKeys: uniqSortedStrings(reportDroppedKeys) } : {},
+      ...hasDroppedTagItems ? { droppedTagItems } : {},
+      ...hasIgnoredAnnotationKeys ? { ignoredAnnotationKeys: uniqSortedStrings(reportIgnoredAnnotationKeys), ignoredAnnotationKeyCount } : {},
+      ...hasDroppedAnnotations ? {
+        droppedAnnotationKeys: uniqSortedStrings(reportDroppedAnnotationKeys),
+        droppedAnnotationKeyCount,
+        droppedAnnotationValues: stats.dropped,
+        droppedAnnotationNonSerializable: stats.nonSerializable,
+        droppedAnnotationDepthExceeded: stats.depthExceeded,
+        droppedAnnotationNonFiniteNumber: stats.nonFiniteNumber
+      } : {}
+    };
+  })();
+  return report ? { meta, report } : { meta };
+};
+var sanitize = (input) => sanitizeWithReport(input).meta;
 
 // src/internal/state-trait/ir.ts
 var normalizeFieldPaths = (paths) => {
@@ -3136,6 +4386,8 @@ var toNodeKind = (step) => {
       return "link";
     case "source-refresh":
       return "source";
+    case "external-store-sync":
+      return "externalStore";
     case "check-validate":
       return "check";
   }
@@ -3160,6 +4412,9 @@ var getReadsForEntry = (entry) => {
     const from = entry.meta.from;
     return from ? [from] : [];
   }
+  if (entry.kind === "externalStore") {
+    return [];
+  }
   if (entry.kind === "check") {
     const rules = entry.meta?.rules ?? {};
     const out = [];
@@ -3207,11 +4462,40 @@ var exportStaticIr = (params) => {
     const write = normalizeFieldPath2(target);
     const writes = write ? [write] : [];
     const meta = target ? metaByField.get(target) : void 0;
+    const externalStorePolicy = () => {
+      if (kind !== "externalStore") return void 0;
+      if (!entry || entry.kind !== "externalStore") return void 0;
+      const descriptor = getExternalStoreDescriptor(entry.meta.store);
+      const storeId = descriptor?.storeId;
+      const priorityRaw = entry.meta?.priority;
+      const lane = priorityRaw === "nonUrgent" ? "nonUrgent" : "urgent";
+      const meta2 = sanitize(entry.meta.meta);
+      const source = descriptor?.kind === "module" ? {
+        kind: "module",
+        storeId,
+        moduleId: descriptor.moduleId,
+        ...descriptor.instanceId ? { instanceKey: descriptor.instanceId } : {},
+        selectorId: descriptor.readQuery.staticIr.selectorId,
+        readsDigest: descriptor.readQuery.staticIr.readsDigest,
+        fallbackReason: descriptor.readQuery.staticIr.fallbackReason
+      } : descriptor ? { kind: "external", storeId } : { kind: "external", storeId: "unknown" };
+      const coalesceWindowMs = entry.meta?.coalesceWindowMs;
+      return {
+        traitId: step.id,
+        storeId: storeId ?? "unknown",
+        source,
+        ownership: "external-owned",
+        lane,
+        ...typeof coalesceWindowMs === "number" && Number.isFinite(coalesceWindowMs) && coalesceWindowMs > 0 ? { coalesceWindowMs } : {},
+        ...meta2 ? { meta: meta2 } : {}
+      };
+    };
     const base2 = {
       nodeId: step.id,
       kind,
       reads,
       writes: kind === "check" ? [] : writes,
+      ...kind === "externalStore" ? { policy: externalStorePolicy() } : {},
       meta
     };
     if (kind !== "check" && target && !write) {
@@ -3323,7 +4607,7 @@ var resolveActions = (input) => {
   for (const actionTag of actionTags) {
     const token = actionMap[actionTag];
     const source = resolveTokenSource(token) ?? moduleSource;
-    const payloadKind = isActionToken(token) && import_effect27.Schema.isSchema(token.schema) ? token.schema === import_effect27.Schema.Void ? "void" : "nonVoid" : "unknown";
+    const payloadKind = isActionToken(token) && import_effect30.Schema.isSchema(token.schema) ? token.schema === import_effect30.Schema.Void ? "void" : "nonVoid" : "unknown";
     const primaryReducer = reducers && typeof reducers[actionTag] === "function" ? { kind: "declared" } : void 0;
     out.push({
       actionTag,
@@ -3376,7 +4660,7 @@ var resolveEffects = (input) => {
     deduped.push(item);
   }
   deduped.sort(
-    (a, b) => a.actionTag < b.actionTag ? -1 : a.actionTag > b.actionTag ? 1 : a.sourceKey.localeCompare(b.sourceKey)
+    (a, b) => a.actionTag < b.actionTag ? -1 : a.actionTag > b.actionTag ? 1 : a.sourceKey < b.sourceKey ? -1 : a.sourceKey > b.sourceKey ? 1 : 0
   );
   return deduped.length > 0 ? deduped : void 0;
 };
@@ -3421,7 +4705,7 @@ var resolveLogicUnits = (input) => {
     const name = typeof unit.name === "string" ? unit.name : void 0;
     out.push({ kind, id, derived, name });
   }
-  out.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : a.kind.localeCompare(b.kind));
+  out.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0);
   return out.length > 0 ? out : void 0;
 };
 var digestOf = (base) => `manifest:067:${fnv1a32(stableStringify(base))}`;
@@ -3556,13 +4840,13 @@ var extractManifest = (module2, options) => {
 };
 
 // src/internal/runtime/Runtime.ts
-var import_effect31 = require("effect");
+var import_effect34 = require("effect");
 
 // src/internal/runtime/AppRuntime.ts
-var import_effect30 = require("effect");
+var import_effect33 = require("effect");
 
-// src/internal/runtime/core/process/ProcessRuntime.ts
-var import_effect29 = require("effect");
+// src/internal/runtime/core/process/ProcessRuntime.make.ts
+var import_effect32 = require("effect");
 
 // src/internal/runtime/core/process/identity.ts
 var scopeKeyFromScope = (scope) => {
@@ -3582,7 +4866,7 @@ var processInstanceIdFromIdentity = (identity) => {
 };
 
 // src/internal/runtime/core/process/concurrency.ts
-var import_effect28 = require("effect");
+var import_effect31 = require("effect");
 var DEFAULT_SERIAL_QUEUE_GUARD_LIMIT = 4096;
 var DEFAULT_PARALLEL_LIMIT = 16;
 var resolveQueueLimit = (maxQueue, options) => {
@@ -3593,37 +4877,37 @@ var resolveQueueLimit = (maxQueue, options) => {
     guard: configured === "unbounded" ? defaultGuard : configured
   };
 };
-var runProcessTriggerStream = (args) => import_effect28.Effect.gen(function* () {
+var runProcessTriggerStream = (args) => import_effect31.Effect.gen(function* () {
   const policy = args.policy;
   const defaultQueueGuard = args.defaultQueueGuard ?? DEFAULT_SERIAL_QUEUE_GUARD_LIMIT;
   if (policy.mode === "latest") {
-    const stateRef = yield* import_effect28.Ref.make({ fiber: void 0, runningId: 0, nextId: 0 });
-    const onTrigger2 = (trigger0) => import_effect28.Effect.gen(function* () {
+    const stateRef = yield* import_effect31.Ref.make({ fiber: void 0, runningId: 0, nextId: 0 });
+    const onTrigger2 = (trigger0) => import_effect31.Effect.gen(function* () {
       const trigger = args.assignTriggerSeq(trigger0);
-      const [prevFiber, prevRunningId, runId] = yield* import_effect28.Ref.modify(stateRef, (s) => {
+      const [prevFiber, prevRunningId, runId] = yield* import_effect31.Ref.modify(stateRef, (s) => {
         const nextId = s.nextId + 1;
         return [[s.fiber, s.runningId, nextId], { ...s, nextId, runningId: nextId }];
       });
       if (prevFiber && prevRunningId !== 0) {
-        const done = yield* import_effect28.Fiber.poll(prevFiber);
-        if (import_effect28.Option.isNone(done)) {
-          yield* import_effect28.Fiber.interruptFork(prevFiber);
+        const done = yield* import_effect31.Fiber.poll(prevFiber);
+        if (import_effect31.Option.isNone(done)) {
+          yield* import_effect31.Fiber.interruptFork(prevFiber);
         }
       }
-      const fiber = yield* import_effect28.Effect.forkScoped(
-        args.run(trigger).pipe(import_effect28.Effect.ensuring(import_effect28.Ref.update(stateRef, (s) => s.runningId === runId ? { ...s, runningId: 0 } : s)))
+      const fiber = yield* import_effect31.Effect.forkScoped(
+        args.run(trigger).pipe(import_effect31.Effect.ensuring(import_effect31.Ref.update(stateRef, (s) => s.runningId === runId ? { ...s, runningId: 0 } : s)))
       );
-      yield* import_effect28.Ref.update(stateRef, (s) => ({ ...s, fiber }));
+      yield* import_effect31.Ref.update(stateRef, (s) => ({ ...s, fiber }));
     });
-    return yield* import_effect28.Stream.runForEach(args.stream, onTrigger2);
+    return yield* import_effect31.Stream.runForEach(args.stream, onTrigger2);
   }
-  const busyRef = yield* import_effect28.Ref.make(false);
-  const serialStateRef = yield* import_effect28.Ref.make({
+  const busyRef = yield* import_effect31.Ref.make(false);
+  const serialStateRef = yield* import_effect31.Ref.make({
     running: false,
     queue: [],
     peak: 0
   });
-  const parallelStateRef = yield* import_effect28.Ref.make({
+  const parallelStateRef = yield* import_effect31.Ref.make({
     active: 0,
     queue: [],
     peak: 0
@@ -3631,57 +4915,57 @@ var runProcessTriggerStream = (args) => import_effect28.Effect.gen(function* ()
   const serialQueueLimit = resolveQueueLimit(policy.maxQueue, { defaultGuard: defaultQueueGuard });
   const parallelQueueLimit = resolveQueueLimit(void 0, { defaultGuard: defaultQueueGuard });
   const parallelLimit = typeof policy.maxParallel === "number" && Number.isFinite(policy.maxParallel) && policy.maxParallel >= 1 ? Math.floor(policy.maxParallel) : args.defaultParallelLimit ?? DEFAULT_PARALLEL_LIMIT;
-  const drainSerial = () => import_effect28.Effect.suspend(
-    () => import_effect28.Ref.modify(serialStateRef, (state) => {
+  const drainSerial = () => import_effect31.Effect.suspend(
+    () => import_effect31.Ref.modify(serialStateRef, (state) => {
       if (state.running || state.queue.length === 0) {
-        return [import_effect28.Option.none(), state];
+        return [import_effect31.Option.none(), state];
       }
       const [next, ...rest] = state.queue;
-      return [import_effect28.Option.some(next), { ...state, running: true, queue: rest }];
+      return [import_effect31.Option.some(next), { ...state, running: true, queue: rest }];
     }).pipe(
-      import_effect28.Effect.flatMap(
-        (next) => import_effect28.Option.match(next, {
-          onNone: () => import_effect28.Effect.void,
-          onSome: (trigger) => import_effect28.Effect.forkScoped(
+      import_effect31.Effect.flatMap(
+        (next) => import_effect31.Option.match(next, {
+          onNone: () => import_effect31.Effect.void,
+          onSome: (trigger) => import_effect31.Effect.forkScoped(
             args.run(trigger).pipe(
-              import_effect28.Effect.ensuring(import_effect28.Ref.update(serialStateRef, (s) => ({ ...s, running: false }))),
-              import_effect28.Effect.zipRight(drainSerial())
+              import_effect31.Effect.ensuring(import_effect31.Ref.update(serialStateRef, (s) => ({ ...s, running: false }))),
+              import_effect31.Effect.zipRight(drainSerial())
             )
-          ).pipe(import_effect28.Effect.asVoid)
+          ).pipe(import_effect31.Effect.asVoid)
         })
       )
     )
   );
-  const drainParallel = () => import_effect28.Effect.suspend(
-    () => import_effect28.Ref.modify(parallelStateRef, (state) => {
+  const drainParallel = () => import_effect31.Effect.suspend(
+    () => import_effect31.Ref.modify(parallelStateRef, (state) => {
       if (state.active >= parallelLimit || state.queue.length === 0) {
-        return [import_effect28.Option.none(), state];
+        return [import_effect31.Option.none(), state];
       }
       const [next, ...rest] = state.queue;
-      return [import_effect28.Option.some(next), { ...state, active: state.active + 1, queue: rest }];
+      return [import_effect31.Option.some(next), { ...state, active: state.active + 1, queue: rest }];
     }).pipe(
-      import_effect28.Effect.flatMap(
-        (next) => import_effect28.Option.match(next, {
-          onNone: () => import_effect28.Effect.void,
-          onSome: (trigger) => import_effect28.Effect.forkScoped(
+      import_effect31.Effect.flatMap(
+        (next) => import_effect31.Option.match(next, {
+          onNone: () => import_effect31.Effect.void,
+          onSome: (trigger) => import_effect31.Effect.forkScoped(
             args.run(trigger).pipe(
-              import_effect28.Effect.ensuring(
-                import_effect28.Ref.update(parallelStateRef, (s) => ({
+              import_effect31.Effect.ensuring(
+                import_effect31.Ref.update(parallelStateRef, (s) => ({
                   ...s,
                   active: Math.max(0, s.active - 1)
                 }))
               ),
-              import_effect28.Effect.zipRight(drainParallel())
+              import_effect31.Effect.zipRight(drainParallel())
             )
-          ).pipe(import_effect28.Effect.asVoid, import_effect28.Effect.zipRight(drainParallel()))
+          ).pipe(import_effect31.Effect.asVoid, import_effect31.Effect.zipRight(drainParallel()))
         })
       )
     )
   );
-  const onTrigger = (trigger0) => import_effect28.Effect.gen(function* () {
+  const onTrigger = (trigger0) => import_effect31.Effect.gen(function* () {
     const trigger = args.assignTriggerSeq(trigger0);
     if (policy.mode === "drop") {
-      const acquired = yield* import_effect28.Ref.modify(
+      const acquired = yield* import_effect31.Ref.modify(
         busyRef,
         (busy) => busy ? [false, busy] : [true, true]
       );
@@ -3689,16 +4973,16 @@ var runProcessTriggerStream = (args) => import_effect28.Effect.gen(function* ()
         yield* args.onDrop(trigger);
         return;
       }
-      yield* import_effect28.Effect.forkScoped(args.run(trigger).pipe(import_effect28.Effect.ensuring(import_effect28.Ref.set(busyRef, false))));
+      yield* import_effect31.Effect.forkScoped(args.run(trigger).pipe(import_effect31.Effect.ensuring(import_effect31.Ref.set(busyRef, false))));
       return;
     }
     if (policy.mode === "parallel") {
-      const nextSize2 = yield* import_effect28.Ref.modify(parallelStateRef, (state) => {
+      const nextSize2 = yield* import_effect31.Ref.modify(parallelStateRef, (state) => {
         const queue = [...state.queue, trigger];
         return [queue.length, { ...state, queue, peak: Math.max(state.peak, queue.length) }];
       });
       if (nextSize2 > parallelQueueLimit.guard) {
-        const state = yield* import_effect28.Ref.get(parallelStateRef);
+        const state = yield* import_effect31.Ref.get(parallelStateRef);
         yield* args.onQueueOverflow({
           mode: "parallel",
           currentLength: nextSize2,
@@ -3711,12 +4995,12 @@ var runProcessTriggerStream = (args) => import_effect28.Effect.gen(function* ()
       yield* drainParallel();
       return;
     }
-    const nextSize = yield* import_effect28.Ref.modify(serialStateRef, (state) => {
+    const nextSize = yield* import_effect31.Ref.modify(serialStateRef, (state) => {
       const queue = [...state.queue, trigger];
       return [queue.length, { ...state, queue, peak: Math.max(state.peak, queue.length) }];
     });
     if (nextSize > serialQueueLimit.guard) {
-      const state = yield* import_effect28.Ref.get(serialStateRef);
+      const state = yield* import_effect31.Ref.get(serialStateRef);
       yield* args.onQueueOverflow({
         mode: "serial",
         currentLength: nextSize,
@@ -3728,7 +5012,7 @@ var runProcessTriggerStream = (args) => import_effect28.Effect.gen(function* ()
     }
     yield* drainSerial();
   });
-  return yield* import_effect28.Stream.runForEach(args.stream, onTrigger);
+  return yield* import_effect31.Stream.runForEach(args.stream, onTrigger);
 });
 
 // src/internal/runtime/core/process/events.ts
@@ -4103,11 +5387,11 @@ var onFailure = (policy, state, nowMs) => {
   };
 };
 
-// src/internal/runtime/core/process/ProcessRuntime.ts
-var ProcessRuntimeTag = class extends import_effect29.Context.Tag("@logixjs/core/ProcessRuntime")() {
+// src/internal/runtime/core/process/ProcessRuntime.make.ts
+var ProcessRuntimeTag = class extends import_effect32.Context.Tag("@logixjs/core/ProcessRuntime")() {
 };
-var currentProcessTrigger = import_effect29.FiberRef.unsafeMake(void 0);
-var currentProcessEventBudget = import_effect29.FiberRef.unsafeMake(
+var currentProcessTrigger = import_effect32.FiberRef.unsafeMake(void 0);
+var currentProcessEventBudget = import_effect32.FiberRef.unsafeMake(
   void 0
 );
 var RUNTIME_BOOT_EVENT = "runtime:boot";
@@ -4166,13 +5450,13 @@ var actionIdFromUnknown = (action) => {
   if (typeof anyAction.type === "string" && anyAction.type.length > 0) return anyAction.type;
   return void 0;
 };
-var make5 = (options) => import_effect29.Effect.gen(function* () {
-  const runtimeScope = yield* import_effect29.Effect.scope;
+var make5 = (options) => import_effect32.Effect.gen(function* () {
+  const runtimeScope = yield* import_effect32.Effect.scope;
   const maxEventHistory = typeof options?.maxEventHistory === "number" && Number.isFinite(options.maxEventHistory) && options.maxEventHistory >= 0 ? Math.floor(options.maxEventHistory) : 500;
   const installations = /* @__PURE__ */ new Map();
   const instances = /* @__PURE__ */ new Map();
   const eventsBuffer = [];
-  const eventsHub = yield* import_effect29.PubSub.sliding(Math.max(1, Math.min(2048, maxEventHistory)));
+  const eventsHub = yield* import_effect32.PubSub.sliding(Math.max(1, Math.min(2048, maxEventHistory)));
   const trimEvents = () => {
     if (maxEventHistory <= 0) {
       eventsBuffer.length = 0;
@@ -4182,8 +5466,8 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     const excess = eventsBuffer.length - maxEventHistory;
     eventsBuffer.splice(0, excess);
   };
-  const recordDebugEvent = (event) => import_effect29.Effect.gen(function* () {
-    const diagnosticsLevel2 = yield* import_effect29.FiberRef.get(currentDiagnosticsLevel);
+  const recordDebugEvent = (event) => import_effect32.Effect.gen(function* () {
+    const diagnosticsLevel2 = yield* import_effect32.FiberRef.get(currentDiagnosticsLevel);
     if (diagnosticsLevel2 === "off") {
       return;
     }
@@ -4206,16 +5490,16 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       txnId
     });
   });
-  const publishEvent = (event) => import_effect29.Effect.gen(function* () {
+  const publishEvent = (event) => import_effect32.Effect.gen(function* () {
     eventsBuffer.push(event);
     trimEvents();
-    yield* import_effect29.PubSub.publish(eventsHub, event);
+    yield* import_effect32.PubSub.publish(eventsHub, event);
     yield* recordDebugEvent(event);
   });
-  const emit = (event) => import_effect29.Effect.gen(function* () {
-    const budgetRef = yield* import_effect29.FiberRef.get(currentProcessEventBudget);
+  const emit = (event) => import_effect32.Effect.gen(function* () {
+    const budgetRef = yield* import_effect32.FiberRef.get(currentProcessEventBudget);
     if (budgetRef) {
-      const decision = yield* import_effect29.Ref.modify(budgetRef, (state) => {
+      const decision = yield* import_effect32.Ref.modify(budgetRef, (state) => {
         const [nextDecision, nextState] = applyProcessRunEventBudget(state, event);
         return [nextDecision, nextState];
       });
@@ -4229,7 +5513,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
   });
   const emitErrorDiagnostic = (scope, processId, code, message, hint) => {
     if (!isDevEnv()) {
-      return import_effect29.Effect.void;
+      return import_effect32.Effect.void;
     }
     const moduleId = scope.type === "moduleInstance" ? scope.moduleId : void 0;
     const instanceId = scope.type === "moduleInstance" ? scope.instanceId : void 0;
@@ -4258,15 +5542,15 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     const missing = [];
     for (const dep of requires) {
       if (typeof dep !== "string" || dep.length === 0) continue;
-      const tag = import_effect29.Context.Tag(`@logixjs/Module/${dep}`)();
-      const found = import_effect29.Context.getOption(installation.env, tag);
-      if (import_effect29.Option.isNone(found)) {
+      const tag = import_effect32.Context.Tag(`@logixjs/Module/${dep}`)();
+      const found = import_effect32.Context.getOption(installation.env, tag);
+      if (import_effect32.Option.isNone(found)) {
         missing.push(dep);
       }
     }
     return missing;
   };
-  const stopInstance = (instance, reason) => import_effect29.Effect.gen(function* () {
+  const stopInstance = (instance, reason) => import_effect32.Effect.gen(function* () {
     if (instance.status.status === "stopped" || instance.status.status === "failed" || instance.status.status === "stopping") {
       return;
     }
@@ -4277,9 +5561,9 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       stoppedReason: reason
     };
     if (fiber) {
-      yield* import_effect29.Fiber.interrupt(fiber);
+      yield* import_effect32.Fiber.interrupt(fiber);
     }
-    yield* import_effect29.Queue.shutdown(instance.platformTriggersQueue);
+    yield* import_effect32.Queue.shutdown(instance.platformTriggersQueue);
     instance.status = {
       ...instance.status,
       status: "stopped",
@@ -4300,7 +5584,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       yield* startInstallation(instance.installationKey);
     }
   });
-  const startInstallation = (installationKey) => import_effect29.Effect.gen(function* () {
+  const startInstallation = (installationKey) => import_effect32.Effect.gen(function* () {
     const installation = installations.get(installationKey);
     if (!installation) return;
     installation.pendingStart = void 0;
@@ -4319,7 +5603,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       runSeq
     };
     const processInstanceId = processInstanceIdFromIdentity(identity);
-    const platformTriggersQueue = yield* import_effect29.Queue.sliding(64);
+    const platformTriggersQueue = yield* import_effect32.Queue.sliding(64);
     const instanceState = {
       installationKey,
       processInstanceId,
@@ -4338,15 +5622,15 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     instances.set(processInstanceId, instanceState);
     installation.currentInstanceId = processInstanceId;
     if (installation.forkScope !== runtimeScope) {
-      yield* import_effect29.Scope.addFinalizer(
+      yield* import_effect32.Scope.addFinalizer(
         installation.forkScope,
-        import_effect29.Effect.suspend(() => {
+        import_effect32.Effect.suspend(() => {
           const status = instanceState.status.status;
           if (status === "stopped" || status === "failed" || status === "stopping") {
-            return import_effect29.Effect.void;
+            return import_effect32.Effect.void;
           }
           return stopInstance(instanceState, "scopeDisposed");
-        }).pipe(import_effect29.Effect.catchAllCause(() => import_effect29.Effect.void))
+        }).pipe(import_effect32.Effect.catchAllCause(() => import_effect32.Effect.void))
       );
     }
     yield* emit({
@@ -4409,12 +5693,12 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       let nextEnv = baseEnv;
       for (const moduleId of ids) {
         if (typeof moduleId !== "string" || moduleId.length === 0) continue;
-        const tag = import_effect29.Context.Tag(`@logixjs/Module/${moduleId}`)();
-        const found = import_effect29.Context.getOption(baseEnv, tag);
-        if (import_effect29.Option.isNone(found)) continue;
+        const tag = import_effect32.Context.Tag(`@logixjs/Module/${moduleId}`)();
+        const found = import_effect32.Context.getOption(baseEnv, tag);
+        if (import_effect32.Option.isNone(found)) continue;
         const runtime = found.value;
-        const recordDispatch = (action) => import_effect29.Effect.gen(function* () {
-          const trigger = yield* import_effect29.FiberRef.get(currentProcessTrigger);
+        const recordDispatch = (action) => import_effect32.Effect.gen(function* () {
+          const trigger = yield* import_effect32.FiberRef.get(currentProcessTrigger);
           if (!trigger) return;
           const actionId = actionIdFromUnknown(action) ?? "unknown";
           const dispatchModuleId = typeof runtime.moduleId === "string" ? runtime.moduleId : moduleId;
@@ -4436,27 +5720,27 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         });
         const wrapped = {
           ...runtime,
-          dispatch: (action) => runtime.dispatch(action).pipe(import_effect29.Effect.tap(() => recordDispatch(action))),
-          dispatchLowPriority: (action) => runtime.dispatchLowPriority(action).pipe(import_effect29.Effect.tap(() => recordDispatch(action))),
-          dispatchBatch: (actions) => runtime.dispatchBatch(actions).pipe(import_effect29.Effect.tap(() => import_effect29.Effect.forEach(actions, recordDispatch, { discard: true })))
+          dispatch: (action) => runtime.dispatch(action).pipe(import_effect32.Effect.tap(() => recordDispatch(action))),
+          dispatchLowPriority: (action) => runtime.dispatchLowPriority(action).pipe(import_effect32.Effect.tap(() => recordDispatch(action))),
+          dispatchBatch: (actions) => runtime.dispatchBatch(actions).pipe(import_effect32.Effect.tap(() => import_effect32.Effect.forEach(actions, recordDispatch, { discard: true })))
         };
-        nextEnv = import_effect29.Context.add(tag, wrapped)(nextEnv);
+        nextEnv = import_effect32.Context.add(tag, wrapped)(nextEnv);
       }
       return nextEnv;
     };
     const wrappedEnv = makeWrappedEnv();
-    const providedProcess = import_effect29.Effect.provide(installation.process, wrappedEnv);
-    const makeTriggerStream = (spec) => import_effect29.Effect.gen(function* () {
+    const providedProcess = import_effect32.Effect.provide(installation.process, wrappedEnv);
+    const makeTriggerStream = (spec) => import_effect32.Effect.gen(function* () {
       if (spec.kind === "timer") {
-        const interval = import_effect29.Duration.decodeUnknown(spec.timerId);
-        if (import_effect29.Option.isNone(interval)) {
+        const interval = import_effect32.Duration.decodeUnknown(spec.timerId);
+        if (import_effect32.Option.isNone(interval)) {
           const err = new Error(`[ProcessRuntime] invalid timerId (expected DurationInput): ${spec.timerId}`);
           err.code = "process::invalid_timer_id";
           err.hint = "timerId must be a valid DurationInput string, e.g. '10 millis', '1 seconds', '5 minutes'.";
-          return yield* import_effect29.Effect.fail(err);
+          return yield* import_effect32.Effect.fail(err);
         }
-        return import_effect29.Stream.tick(interval.value).pipe(
-          import_effect29.Stream.map(
+        return import_effect32.Stream.tick(interval.value).pipe(
+          import_effect32.Stream.map(
             () => ({
               kind: "timer",
               name: spec.name,
@@ -4466,10 +5750,10 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         );
       }
       if (spec.kind === "moduleAction") {
-        const tag2 = import_effect29.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
-        const found2 = import_effect29.Context.getOption(baseEnv, tag2);
-        if (import_effect29.Option.isNone(found2)) {
-          return yield* import_effect29.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
+        const tag2 = import_effect32.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
+        const found2 = import_effect32.Context.getOption(baseEnv, tag2);
+        if (import_effect32.Option.isNone(found2)) {
+          return yield* import_effect32.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
         }
         const runtime2 = found2.value;
         if (!shouldRecordChainEvents) {
@@ -4478,11 +5762,11 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
             const err = new Error("ModuleRuntime does not provide actions$ (required for moduleAction trigger).");
             err.code = "process::missing_action_stream";
             err.hint = `moduleId=${spec.moduleId}`;
-            return yield* import_effect29.Effect.fail(err);
+            return yield* import_effect32.Effect.fail(err);
           }
           return stream2.pipe(
-            import_effect29.Stream.filter((action) => actionIdFromUnknown(action) === spec.actionId),
-            import_effect29.Stream.map(
+            import_effect32.Stream.filter((action) => actionIdFromUnknown(action) === spec.actionId),
+            import_effect32.Stream.map(
               () => ({
                 kind: "moduleAction",
                 name: spec.name,
@@ -4501,11 +5785,11 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
           );
           err.code = "process::missing_action_meta_stream";
           err.hint = `moduleId=${spec.moduleId}`;
-          return yield* import_effect29.Effect.fail(err);
+          return yield* import_effect32.Effect.fail(err);
         }
         return stream.pipe(
-          import_effect29.Stream.filter((evt) => actionIdFromUnknown(evt.value) === spec.actionId),
-          import_effect29.Stream.map((evt) => {
+          import_effect32.Stream.filter((evt) => actionIdFromUnknown(evt.value) === spec.actionId),
+          import_effect32.Stream.map((evt) => {
             const txnSeq = evt?.meta?.txnSeq;
             return {
               kind: "moduleAction",
@@ -4518,21 +5802,21 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
           })
         );
       }
-      const tag = import_effect29.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
-      const found = import_effect29.Context.getOption(baseEnv, tag);
-      if (import_effect29.Option.isNone(found)) {
-        return yield* import_effect29.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
+      const tag = import_effect32.Context.Tag(`@logixjs/Module/${spec.moduleId}`)();
+      const found = import_effect32.Context.getOption(baseEnv, tag);
+      if (import_effect32.Option.isNone(found)) {
+        return yield* import_effect32.Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
       }
       const runtime = found.value;
       const schemaAst = resolveRuntimeStateSchemaAst(runtime);
       const selectorResult = makeSchemaSelector(spec.path, schemaAst);
       if (!selectorResult.ok) {
-        return yield* import_effect29.Effect.fail(withModuleHint(selectorResult.error, spec.moduleId));
+        return yield* import_effect32.Effect.fail(withModuleHint(selectorResult.error, spec.moduleId));
       }
       const selectorBase = selectorResult.selector;
-      const prevRef = yield* import_effect29.Ref.make(import_effect29.Option.none());
+      const prevRef = yield* import_effect32.Ref.make(import_effect32.Option.none());
       const enableSelectorDiagnostics = shouldRecordChainEvents;
-      const selectorDiagnosticsRef = enableSelectorDiagnostics ? yield* import_effect29.Ref.make({
+      const selectorDiagnosticsRef = enableSelectorDiagnostics ? yield* import_effect32.Ref.make({
         windowStartedMs: Date.now(),
         triggersInWindow: 0,
         lastWarningAtMs: 0
@@ -4571,11 +5855,11 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       } : selectorBase;
       const maybeWarnSelector = (trigger) => {
         if (!selectorDiagnosticsRef) {
-          return import_effect29.Effect.void;
+          return import_effect32.Effect.void;
         }
-        return import_effect29.Effect.gen(function* () {
+        return import_effect32.Effect.gen(function* () {
           const now = Date.now();
-          const decision = yield* import_effect29.Ref.modify(selectorDiagnosticsRef, (s) => {
+          const decision = yield* import_effect32.Ref.modify(selectorDiagnosticsRef, (s) => {
             const windowExpired = now - s.windowStartedMs >= triggerWindowMs;
             const windowStartedMs = windowExpired ? now : s.windowStartedMs;
             const triggersInWindow = windowExpired ? 1 : s.triggersInWindow + 1;
@@ -4643,18 +5927,18 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         });
       };
       const baseStream = runtime.changesWithMeta(selector).pipe(
-        import_effect29.Stream.mapEffect(
-          (evt) => import_effect29.Ref.get(prevRef).pipe(
-            import_effect29.Effect.flatMap((prev) => {
-              if (import_effect29.Option.isSome(prev) && Object.is(prev.value, evt.value)) {
-                return import_effect29.Effect.succeed(import_effect29.Option.none());
+        import_effect32.Stream.mapEffect(
+          (evt) => import_effect32.Ref.get(prevRef).pipe(
+            import_effect32.Effect.flatMap((prev) => {
+              if (import_effect32.Option.isSome(prev) && Object.is(prev.value, evt.value)) {
+                return import_effect32.Effect.succeed(import_effect32.Option.none());
               }
-              return import_effect29.Ref.set(prevRef, import_effect29.Option.some(evt.value)).pipe(import_effect29.Effect.as(import_effect29.Option.some(evt)));
+              return import_effect32.Ref.set(prevRef, import_effect32.Option.some(evt.value)).pipe(import_effect32.Effect.as(import_effect32.Option.some(evt)));
             })
           )
         ),
-        import_effect29.Stream.filterMap((opt) => opt),
-        import_effect29.Stream.map((evt) => {
+        import_effect32.Stream.filterMap((opt) => opt),
+        import_effect32.Stream.map((evt) => {
           const txnSeq = evt?.meta?.txnSeq;
           return {
             kind: "moduleStateChange",
@@ -4666,20 +5950,20 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
           };
         })
       );
-      return enableSelectorDiagnostics ? baseStream.pipe(import_effect29.Stream.tap(maybeWarnSelector)) : baseStream;
+      return enableSelectorDiagnostics ? baseStream.pipe(import_effect32.Stream.tap(maybeWarnSelector)) : baseStream;
     });
-    const makeRun = (trigger, fatal) => import_effect29.Effect.locally(
+    const makeRun = (trigger, fatal) => import_effect32.Effect.locally(
       currentProcessTrigger,
       trigger
     )(
       providedProcess.pipe(
-        import_effect29.Effect.catchAllCause((cause) => {
-          if (import_effect29.Cause.isInterruptedOnly(cause)) {
-            return import_effect29.Effect.void;
+        import_effect32.Effect.catchAllCause((cause) => {
+          if (import_effect32.Cause.isInterruptedOnly(cause)) {
+            return import_effect32.Effect.void;
           }
-          return import_effect29.Deferred.succeed(fatal, cause).pipe(
-            import_effect29.Effect.asVoid,
-            import_effect29.Effect.catchAll(() => import_effect29.Effect.void)
+          return import_effect32.Deferred.succeed(fatal, cause).pipe(
+            import_effect32.Effect.asVoid,
+            import_effect32.Effect.catchAll(() => import_effect32.Effect.void)
           );
         })
       )
@@ -4688,12 +5972,12 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       if (!shouldRecordChainEvents) {
         return makeRun(trigger, fatal);
       }
-      return import_effect29.Effect.gen(function* () {
-        const budgetRef = yield* import_effect29.Ref.make(makeProcessRunEventBudgetState());
-        return yield* import_effect29.Effect.locally(
+      return import_effect32.Effect.gen(function* () {
+        const budgetRef = yield* import_effect32.Ref.make(makeProcessRunEventBudgetState());
+        return yield* import_effect32.Effect.locally(
           currentProcessEventBudget,
           budgetRef
-        )(emitTriggerEvent(trigger, "info").pipe(import_effect29.Effect.zipRight(makeRun(trigger, fatal))));
+        )(emitTriggerEvent(trigger, "info").pipe(import_effect32.Effect.zipRight(makeRun(trigger, fatal))));
       });
     };
     const assignTriggerSeq = (trigger) => {
@@ -4707,7 +5991,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     };
     const emitTriggerEvent = (trigger, severity) => {
       if (!shouldRecordChainEvents) {
-        return import_effect29.Effect.void;
+        return import_effect32.Effect.void;
       }
       const evt = {
         type: "process:trigger",
@@ -4726,16 +6010,16 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     const bootTriggerSpec = installation.definition.triggers.find(
       (t) => t.kind === "platformEvent" && t.platformEvent === RUNTIME_BOOT_EVENT
     );
-    const instanceProgram = import_effect29.Effect.gen(function* () {
-      const fatal = yield* import_effect29.Deferred.make();
-      const platformEventStream = import_effect29.Stream.fromQueue(
+    const instanceProgram = import_effect32.Effect.gen(function* () {
+      const fatal = yield* import_effect32.Deferred.make();
+      const platformEventStream = import_effect32.Stream.fromQueue(
         instanceState.platformTriggersQueue
       );
       const nonPlatformTriggers = installation.definition.triggers.filter(
         (t) => t.kind !== "platformEvent"
       );
-      const streams = yield* import_effect29.Effect.forEach(nonPlatformTriggers, makeTriggerStream);
-      const triggerStream = import_effect29.Stream.mergeAll([platformEventStream, ...streams], {
+      const streams = yield* import_effect32.Effect.forEach(nonPlatformTriggers, makeTriggerStream);
+      const triggerStream = import_effect32.Stream.mergeAll([platformEventStream, ...streams], {
         concurrency: "unbounded"
       });
       const reportQueueOverflow = (info) => {
@@ -4750,12 +6034,12 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
           "fix:",
           "- Configure concurrency.maxQueue (serial) to a finite value, or switch to mode=latest/drop to avoid unbounded backlog."
         ].join("\n");
-        return import_effect29.Deferred.succeed(fatal, import_effect29.Cause.fail(err)).pipe(
-          import_effect29.Effect.asVoid,
-          import_effect29.Effect.catchAll(() => import_effect29.Effect.void)
+        return import_effect32.Deferred.succeed(fatal, import_effect32.Cause.fail(err)).pipe(
+          import_effect32.Effect.asVoid,
+          import_effect32.Effect.catchAll(() => import_effect32.Effect.void)
         );
       };
-      const runnerFiber = yield* import_effect29.Effect.forkScoped(
+      const runnerFiber = yield* import_effect32.Effect.forkScoped(
         runProcessTriggerStream({
           stream: triggerStream,
           policy,
@@ -4766,21 +6050,21 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         })
       );
       if (autoStart) {
-        yield* import_effect29.Queue.offer(instanceState.platformTriggersQueue, {
+        yield* import_effect32.Queue.offer(instanceState.platformTriggersQueue, {
           kind: "platformEvent",
           name: bootTriggerSpec?.name,
           platformEvent: RUNTIME_BOOT_EVENT
         });
       }
-      const cause = yield* import_effect29.Deferred.await(fatal);
-      yield* import_effect29.Fiber.interrupt(runnerFiber);
-      return yield* import_effect29.Effect.failCause(cause);
+      const cause = yield* import_effect32.Deferred.await(fatal);
+      yield* import_effect32.Fiber.interrupt(runnerFiber);
+      return yield* import_effect32.Effect.failCause(cause);
     });
-    const fiber = yield* import_effect29.Effect.forkIn(installation.forkScope)(
-      import_effect29.Effect.scoped(instanceProgram).pipe(
-        import_effect29.Effect.catchAllCause(
-          (cause) => import_effect29.Effect.gen(function* () {
-            if (import_effect29.Cause.isInterruptedOnly(cause)) {
+    const fiber = yield* import_effect32.Effect.forkIn(installation.forkScope)(
+      import_effect32.Effect.scoped(instanceProgram).pipe(
+        import_effect32.Effect.catchAllCause(
+          (cause) => import_effect32.Effect.gen(function* () {
+            if (import_effect32.Cause.isInterruptedOnly(cause)) {
               if (instanceState.status.status === "stopping") {
                 return;
               }
@@ -4790,7 +6074,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
                 stoppedReason: "scopeDisposed"
               };
               instanceState.fiber = void 0;
-              yield* import_effect29.Effect.uninterruptible(
+              yield* import_effect32.Effect.uninterruptible(
                 emit({
                   type: "process:stop",
                   identity,
@@ -4806,9 +6090,9 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
               }
               return;
             }
-            const primary = import_effect29.Option.getOrElse(
-              import_effect29.Cause.failureOption(cause),
-              () => import_effect29.Option.getOrElse(import_effect29.Cause.dieOption(cause), () => cause)
+            const primary = import_effect32.Option.getOrElse(
+              import_effect32.Cause.failureOption(cause),
+              () => import_effect32.Option.getOrElse(import_effect32.Cause.dieOption(cause), () => cause)
             );
             const summary = toSerializableErrorSummary(primary);
             const error = summary.errorSummary;
@@ -4860,16 +6144,16 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       ...instanceState.status,
       status: "running"
     };
-    yield* import_effect29.Effect.yieldNow();
+    yield* import_effect32.Effect.yieldNow();
   });
-  const install = (process2, options2) => import_effect29.Effect.gen(function* () {
+  const install = (process2, options2) => import_effect32.Effect.gen(function* () {
     const meta = getMeta(process2);
     if (!meta) {
       return void 0;
     }
-    const env = yield* import_effect29.Effect.context();
-    const forkScopeOpt = yield* import_effect29.Effect.serviceOption(import_effect29.Scope.Scope);
-    const forkScope = import_effect29.Option.isSome(forkScopeOpt) ? forkScopeOpt.value : runtimeScope;
+    const env = yield* import_effect32.Effect.context();
+    const forkScopeOpt = yield* import_effect32.Effect.serviceOption(import_effect32.Scope.Scope);
+    const forkScope = import_effect32.Option.isSome(forkScopeOpt) ? forkScopeOpt.value : runtimeScope;
     const scopeKey = scopeKeyFromScope(options2.scope);
     const identity = {
       processId: meta.definition.processId,
@@ -4897,9 +6181,9 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         const mode = options2.mode ?? "switch";
         if (mode === "switch" && current && current.forkScope !== forkScope) {
           existing.pendingStart = { forkScope };
-          yield* import_effect29.Scope.addFinalizer(
+          yield* import_effect32.Scope.addFinalizer(
             forkScope,
-            import_effect29.Effect.sync(() => {
+            import_effect32.Effect.sync(() => {
               const installation2 = installations.get(installationKey);
               if (!installation2) return;
               if (installation2.pendingStart?.forkScope === forkScope) {
@@ -4920,9 +6204,9 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         const mode = options2.mode ?? "switch";
         if (mode === "switch") {
           existing.pendingStart = { forkScope };
-          yield* import_effect29.Scope.addFinalizer(
+          yield* import_effect32.Scope.addFinalizer(
             forkScope,
-            import_effect29.Effect.sync(() => {
+            import_effect32.Effect.sync(() => {
               const installation2 = installations.get(installationKey);
               if (!installation2) return;
               if (installation2.pendingStart?.forkScope === forkScope) {
@@ -4947,7 +6231,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         installedAt: existing.installedAt
       };
     }
-    const derived = import_effect29.Effect.suspend(() => process2);
+    const derived = import_effect32.Effect.suspend(() => process2);
     attachMeta(derived, {
       ...meta,
       installationScope: options2.scope
@@ -4976,7 +6260,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       installedAt: installation.installedAt
     };
   });
-  const listInstallations = (filter) => import_effect29.Effect.sync(() => {
+  const listInstallations = (filter) => import_effect32.Effect.sync(() => {
     const scopeType = filter?.scopeType;
     const scopeKey = filter?.scopeKey;
     const out = [];
@@ -4991,26 +6275,26 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     }
     return out;
   });
-  const getInstanceStatus = (processInstanceId) => import_effect29.Effect.sync(() => instances.get(processInstanceId)?.status);
-  const controlInstance = (processInstanceId, request) => import_effect29.Effect.suspend(() => {
+  const getInstanceStatus = (processInstanceId) => import_effect32.Effect.sync(() => instances.get(processInstanceId)?.status);
+  const controlInstance = (processInstanceId, request) => import_effect32.Effect.suspend(() => {
     const instance = instances.get(processInstanceId);
     if (!instance) {
-      return import_effect29.Effect.void;
+      return import_effect32.Effect.void;
     }
     return shouldNoopDueToSyncTxn(instance.scope, "process_control_in_transaction").pipe(
-      import_effect29.Effect.flatMap((noop) => {
+      import_effect32.Effect.flatMap((noop) => {
         if (noop) {
-          return import_effect29.Effect.void;
+          return import_effect32.Effect.void;
         }
         if (request.action === "stop") {
           return stopInstance(instance, "manualStop");
         }
         if (request.action === "restart") {
           return stopInstance(instance, "manualStop").pipe(
-            import_effect29.Effect.flatMap(() => {
+            import_effect32.Effect.flatMap(() => {
               const installation = installations.get(instance.installationKey);
               if (!installation) {
-                return import_effect29.Effect.void;
+                return import_effect32.Effect.void;
               }
               installation.currentInstanceId = void 0;
               return startInstallation(instance.installationKey);
@@ -5019,20 +6303,20 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         }
         if (request.action === "start") {
           if (instance.status.status === "running" || instance.status.status === "starting") {
-            return import_effect29.Effect.void;
+            return import_effect32.Effect.void;
           }
           const installation = installations.get(instance.installationKey);
           if (!installation) {
-            return import_effect29.Effect.void;
+            return import_effect32.Effect.void;
           }
           installation.currentInstanceId = void 0;
           return startInstallation(instance.installationKey);
         }
-        return import_effect29.Effect.void;
+        return import_effect32.Effect.void;
       })
     );
   });
-  const deliverPlatformEvent = (event) => import_effect29.Effect.gen(function* () {
+  const deliverPlatformEvent = (event) => import_effect32.Effect.gen(function* () {
     const noop = yield* shouldNoopInSyncTransactionFiber({
       code: "process::invalid_usage",
       severity: "error",
@@ -5043,25 +6327,25 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     if (noop) return;
     const targets = Array.from(instances.values());
     const eventName = event.eventName;
-    yield* import_effect29.Effect.forEach(
+    yield* import_effect32.Effect.forEach(
       targets,
-      (instance) => import_effect29.Effect.suspend(() => {
+      (instance) => import_effect32.Effect.suspend(() => {
         if (instance.status.status !== "starting" && instance.status.status !== "running") {
-          return import_effect29.Effect.void;
+          return import_effect32.Effect.void;
         }
         const installation = installations.get(instance.installationKey);
         if (!installation) {
-          return import_effect29.Effect.void;
+          return import_effect32.Effect.void;
         }
         const specs = installation.definition.triggers.filter(
           (t) => t.kind === "platformEvent" && t.platformEvent === eventName
         );
         if (specs.length === 0) {
-          return import_effect29.Effect.void;
+          return import_effect32.Effect.void;
         }
-        return import_effect29.Effect.forEach(
+        return import_effect32.Effect.forEach(
           specs,
-          (spec) => import_effect29.Queue.offer(instance.platformTriggersQueue, {
+          (spec) => import_effect32.Queue.offer(instance.platformTriggersQueue, {
             kind: "platformEvent",
             name: spec.name,
             platformEvent: spec.platformEvent
@@ -5072,10 +6356,10 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
       { discard: true }
     );
   });
-  const eventsStream = import_effect29.Stream.fromPubSub(eventsHub);
-  const getEventsSnapshot = () => import_effect29.Effect.sync(() => eventsBuffer.slice());
-  yield* import_effect29.Effect.addFinalizer(
-    () => import_effect29.Effect.gen(function* () {
+  const eventsStream = import_effect32.Stream.fromPubSub(eventsHub);
+  const getEventsSnapshot = () => import_effect32.Effect.sync(() => eventsBuffer.slice());
+  yield* import_effect32.Effect.addFinalizer(
+    () => import_effect32.Effect.gen(function* () {
       for (const installation of installations.values()) {
         installation.pendingStart = void 0;
       }
@@ -5085,10 +6369,10 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
         }
       }
     }).pipe(
-      import_effect29.Effect.catchAllCause(
-        (cause) => import_effect29.Effect.sync(() => {
+      import_effect32.Effect.catchAllCause(
+        (cause) => import_effect32.Effect.sync(() => {
           if (isDevEnv()) {
-            console.warn("[ProcessRuntime] finalizer failed", import_effect29.Cause.pretty(cause));
+            console.warn("[ProcessRuntime] finalizer failed", import_effect32.Cause.pretty(cause));
           }
         })
       )
@@ -5104,7 +6388,7 @@ var make5 = (options) => import_effect29.Effect.gen(function* () {
     getEventsSnapshot
   };
 });
-var layer3 = (options) => import_effect29.Layer.scoped(ProcessRuntimeTag, make5(options));
+var layer3 = (options) => import_effect32.Layer.scoped(ProcessRuntimeTag, make5(options));
 
 // src/internal/runtime/AppRuntime.ts
 var getTagKey = (tag) => {
@@ -5200,82 +6484,100 @@ Ensure all modules in the application Runtime have unique IDs.`
     seenIds.add(id);
   }
   validateTags(config.modules);
-  const stateTxnLayer = config.stateTransaction ? import_effect30.Layer.succeed(StateTransactionConfigTag, config.stateTransaction) : import_effect30.Layer.empty;
-  const concurrencyPolicyLayer = config.concurrencyPolicy ? import_effect30.Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) : import_effect30.Layer.empty;
-  const readQueryStrictGateLayer = config.readQueryStrictGate ? import_effect30.Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) : import_effect30.Layer.empty;
+  const stateTxnLayer = config.stateTransaction ? import_effect33.Layer.succeed(StateTransactionConfigTag, config.stateTransaction) : import_effect33.Layer.empty;
+  const concurrencyPolicyLayer = config.concurrencyPolicy ? import_effect33.Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) : import_effect33.Layer.empty;
+  const readQueryStrictGateLayer = config.readQueryStrictGate ? import_effect33.Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) : import_effect33.Layer.empty;
   const appModuleIds = config.modules.map((entry) => String(entry.module.id));
   const appId = appModuleIds.length === 1 ? appModuleIds[0] : appModuleIds.slice().sort().join("~");
-  const baseLayer = import_effect30.Layer.mergeAll(
-    config.layer,
+  const pinnedHostSchedulerLayer = config.hostScheduler !== void 0 ? import_effect33.Layer.succeed(HostSchedulerTag, config.hostScheduler) : void 0;
+  const tickServicesLayer = import_effect33.Layer.provideMerge(pinnedHostSchedulerLayer ?? hostSchedulerLayer)(
+    import_effect33.Layer.provideMerge(runtimeStoreLayer)(import_effect33.Layer.provideMerge(declarativeLinkRuntimeLayer)(tickSchedulerLayer()))
+  );
+  const appLayer = config.layer.pipe(import_effect33.Layer.provide(tickServicesLayer));
+  const baseLayer = import_effect33.Layer.mergeAll(
+    tickServicesLayer,
+    appLayer,
+    // If a HostScheduler override is requested, pin it as the final HostSchedulerTag value to avoid accidental divergence.
+    // (Build-time capture is handled above by injecting it into tickServicesLayer.)
+    pinnedHostSchedulerLayer ?? import_effect33.Layer.empty,
     stateTxnLayer,
     concurrencyPolicyLayer,
     readQueryStrictGateLayer,
     layer3(),
-    import_effect30.Layer.effect(
+    import_effect33.Layer.effect(
       RootContextTag,
-      import_effect30.Effect.gen(function* () {
-        const ready = yield* import_effect30.Deferred.make();
+      import_effect33.Effect.gen(function* () {
+        const ready = yield* import_effect33.Deferred.make();
         return { context: void 0, ready, appId, appModuleIds };
       })
     )
   );
-  const moduleLayers = config.modules.map(
-    (entry) => (
-      // Ensure each module layer can see the app Env (baseLayer) to avoid missing root env during initialization.
-      import_effect30.Layer.provide(entry.layer, baseLayer)
-    )
-  );
-  const envLayer = moduleLayers.length > 0 ? import_effect30.Layer.mergeAll(baseLayer, ...moduleLayers) : baseLayer;
-  const finalLayer = import_effect30.Layer.unwrapScoped(
-    import_effect30.Effect.gen(function* () {
-      const scope = yield* import_effect30.Effect.scope;
-      const [patch, env] = yield* import_effect30.Effect.diffFiberRefs(import_effect30.Layer.buildWithScope(envLayer, scope));
-      const rootContext = import_effect30.Context.get(env, RootContextTag);
-      rootContext.context = env;
-      yield* import_effect30.Deferred.succeed(rootContext.ready, env);
-      const processRuntime = import_effect30.Context.get(
-        env,
-        ProcessRuntimeTag
-      );
-      yield* import_effect30.Effect.forEach(
-        config.processes,
-        (process2) => import_effect30.Effect.gen(function* () {
-          const installation = yield* import_effect30.Effect.provide(
-            processRuntime.install(process2, {
-              scope: { type: "app", appId },
-              enabled: true,
-              installedAt: "appRuntime"
+  const finalLayer = import_effect33.Layer.unwrapScoped(
+    import_effect33.Effect.gen(function* () {
+      const scope = yield* import_effect33.Effect.scope;
+      const [patch, env] = yield* import_effect33.Effect.diffFiberRefs(
+        import_effect33.Effect.gen(function* () {
+          const baseEnv = yield* import_effect33.Layer.buildWithScope(baseLayer, scope);
+          const moduleEnv = config.modules.length > 0 ? yield* import_effect33.Effect.provide(
+            import_effect33.Layer.buildWithScope(
+              config.modules.length === 1 ? config.modules[0].layer : config.modules.slice(1).reduce((acc, entry) => import_effect33.Layer.merge(acc, entry.layer), config.modules[0].layer),
+              scope
+            ),
+            baseEnv
+          ) : void 0;
+          const mergedEnv = moduleEnv ? import_effect33.Context.merge(baseEnv, moduleEnv) : baseEnv;
+          const rootContext = import_effect33.Context.get(mergedEnv, RootContextTag);
+          rootContext.context = mergedEnv;
+          yield* import_effect33.Deferred.succeed(rootContext.ready, mergedEnv);
+          const processRuntime = import_effect33.Context.get(
+            mergedEnv,
+            ProcessRuntimeTag
+          );
+          yield* import_effect33.Effect.forEach(
+            config.processes,
+            (process2) => import_effect33.Effect.gen(function* () {
+              const installation = yield* import_effect33.Effect.provide(
+                processRuntime.install(process2, {
+                  scope: { type: "app", appId },
+                  enabled: true,
+                  installedAt: "appRuntime"
+                }),
+                mergedEnv
+              );
+              if (installation === void 0) {
+                yield* import_effect33.Effect.forkScoped(
+                  import_effect33.Effect.provide(
+                    config.onError ? import_effect33.Effect.catchAllCause(process2, config.onError) : process2,
+                    mergedEnv
+                  )
+                );
+              }
             }),
-            env
+            { discard: true }
           );
-          if (installation === void 0) {
-            yield* import_effect30.Effect.forkScoped(
-              import_effect30.Effect.provide(config.onError ? import_effect30.Effect.catchAllCause(process2, config.onError) : process2, env)
-            );
-          }
-        }),
-        { discard: true }
+          return mergedEnv;
+        })
       );
-      const fiberRefsLayer = import_effect30.Layer.scopedDiscard(import_effect30.Effect.patchFiberRefs(patch));
-      return import_effect30.Layer.mergeAll(import_effect30.Layer.succeedContext(env), fiberRefsLayer);
+      const fiberRefsLayer = import_effect33.Layer.scopedDiscard(import_effect33.Effect.patchFiberRefs(patch));
+      return import_effect33.Layer.mergeAll(import_effect33.Layer.succeedContext(env), fiberRefsLayer);
     })
   );
   return {
     definition: config,
     layer: finalLayer,
-    makeRuntime: () => import_effect30.ManagedRuntime.make(finalLayer)
+    makeRuntime: () => import_effect33.ManagedRuntime.make(finalLayer)
   };
 };
 var provide = (module2, resource) => {
-  const layer4 = isLayer(resource) ? resource : import_effect30.Layer.succeed(module2, resource);
+  const layer4 = isLayer(resource) ? resource : import_effect33.Layer.succeed(module2, resource);
   return { module: module2, layer: layer4 };
 };
-var isLayer = (value) => typeof value === "object" && value !== null && import_effect30.Layer.LayerTypeId in value;
+var isLayer = (value) => typeof value === "object" && value !== null && import_effect33.Layer.LayerTypeId in value;
 
 // src/internal/runtime/Runtime.ts
 var make6 = (rootImpl, options) => {
   const appConfig = {
-    layer: options?.layer ?? import_effect31.Layer.empty,
+    layer: options?.layer ?? import_effect34.Layer.empty,
     modules: [provide(rootImpl.module, rootImpl.layer)],
     processes: rootImpl.processes ?? [],
     onError: options?.onError
@@ -5317,9 +6619,7 @@ var toErrorSummaryWithCode = (cause, code, hint) => {
 var defaultArtifactBudgetBytes = 50 * 1024;
 var budgetOf = (budgets) => typeof budgets?.maxBytes === "number" && Number.isFinite(budgets.maxBytes) && budgets.maxBytes > 0 ? budgets.maxBytes : defaultArtifactBudgetBytes;
 var makeConflictEnvelope = (artifactKey, exporterIds) => {
-  const ids = Array.from(new Set(exporterIds.map((s) => String(s)).filter((s) => s.length > 0))).sort(
-    (a, b) => a.localeCompare(b)
-  );
+  const ids = Array.from(new Set(exporterIds.map((s) => String(s)).filter((s) => s.length > 0))).sort();
   return {
     artifactKey,
     envelope: {
@@ -5361,7 +6661,7 @@ var collectTrialRunArtifacts = (options) => {
     if (ka > kb) return 1;
     const ia = String(a?.exporterId ?? "");
     const ib = String(b?.exporterId ?? "");
-    return ia.localeCompare(ib);
+    return ia < ib ? -1 : ia > ib ? 1 : 0;
   });
   const conflicts = /* @__PURE__ */ new Map();
   for (const ex of exportersSorted) {
@@ -5440,11 +6740,11 @@ var collectTrialRunArtifacts = (options) => {
       });
     }
   }
-  for (const conflictKey of Array.from(conflictKeys).sort((a, b) => a.localeCompare(b))) {
+  for (const conflictKey of Array.from(conflictKeys).sort()) {
     collected.push(makeConflictEnvelope(conflictKey, conflicts.get(conflictKey) ?? []));
   }
   if (collected.length === 0) return void 0;
-  collected.sort((a, b) => a.artifactKey.localeCompare(b.artifactKey));
+  collected.sort((a, b) => a.artifactKey < b.artifactKey ? -1 : a.artifactKey > b.artifactKey ? 1 : 0);
   return Object.fromEntries(collected.map((c) => [c.artifactKey, c.envelope]));
 };
 
@@ -5496,7 +6796,7 @@ var parseMissingConfigKeys = (message) => {
       if (typeof key === "string" && key.length > 0) out.push(key);
     }
   }
-  return Array.from(new Set(out)).sort((a, b) => a.localeCompare(b));
+  return Array.from(new Set(out)).sort();
 };
 var parseMissingServiceIds = (message) => {
   const out = [];
@@ -5506,12 +6806,12 @@ var parseMissingServiceIds = (message) => {
     const id = match[1]?.replace(/[,:.;]+$/, "");
     if (typeof id === "string" && id.length > 0) out.push(id);
   }
-  return Array.from(new Set(out)).sort((a, b) => a.localeCompare(b));
+  return Array.from(new Set(out)).sort();
 };
 var parseMissingDependencyFromCause = (cause) => {
   const missingServices = [];
   const missingConfigKeys = [];
-  const candidates = [...Array.from(import_effect32.Cause.failures(cause)), ...Array.from(import_effect32.Cause.defects(cause))];
+  const candidates = [...Array.from(import_effect35.Cause.failures(cause)), ...Array.from(import_effect35.Cause.defects(cause))];
   for (const candidate of candidates) {
     if (isRecord6(candidate) && candidate._tag === "ConstructionGuardError") {
       const missingService = candidate.missingService;
@@ -5539,7 +6839,7 @@ var parseMissingDependencyFromCause = (cause) => {
     }
   }
   try {
-    messages.push(import_effect32.Cause.pretty(cause, { renderErrorCause: true }));
+    messages.push(import_effect35.Cause.pretty(cause, { renderErrorCause: true }));
   } catch {
   }
   const merged = messages.filter((s) => s.length > 0).join("\n");
@@ -5548,19 +6848,17 @@ var parseMissingDependencyFromCause = (cause) => {
     missingConfigKeys.push(...parseMissingConfigKeys(merged));
   }
   return {
-    missingServices: Array.from(new Set(missingServices)).sort((a, b) => a.localeCompare(b)),
-    missingConfigKeys: Array.from(new Set(missingConfigKeys)).sort((a, b) => a.localeCompare(b))
+    missingServices: Array.from(new Set(missingServices)).sort(),
+    missingConfigKeys: Array.from(new Set(missingConfigKeys)).sort()
   };
 };
 var buildEnvironmentIr = (params) => {
-  const providedConfigKeys = Object.keys(params.buildEnvConfig ?? {}).filter((k) => k.length > 0 && params.buildEnvConfig[k] !== void 0).sort((a, b) => a.localeCompare(b));
-  const missingServices = Array.from(new Set(params.missingServices ?? [])).sort((a, b) => a.localeCompare(b));
-  const missingConfigKeys = Array.from(new Set(params.missingConfigKeys ?? [])).sort((a, b) => a.localeCompare(b));
+  const providedConfigKeys = Object.keys(params.buildEnvConfig ?? {}).filter((k) => k.length > 0 && params.buildEnvConfig[k] !== void 0).sort();
+  const missingServices = Array.from(new Set(params.missingServices ?? [])).sort();
+  const missingConfigKeys = Array.from(new Set(params.missingConfigKeys ?? [])).sort();
   const runtimeServiceIds = params.runtimeServicesEvidence?.bindings?.map((b) => b.serviceId).filter((s) => typeof s === "string") ?? [];
-  const tagIds = Array.from(/* @__PURE__ */ new Set([...runtimeServiceIds, ...missingServices])).sort((a, b) => a.localeCompare(b));
-  const configKeys = Array.from(/* @__PURE__ */ new Set([...providedConfigKeys, ...missingConfigKeys])).sort(
-    (a, b) => a.localeCompare(b)
-  );
+  const tagIds = Array.from(/* @__PURE__ */ new Set([...runtimeServiceIds, ...missingServices])).sort();
+  const configKeys = Array.from(/* @__PURE__ */ new Set([...providedConfigKeys, ...missingConfigKeys])).sort();
   return {
     tagIds,
     configKeys,
@@ -5582,25 +6880,25 @@ var toErrorSummaryWithCode2 = (cause, code, hint) => {
 var makeTrialRunTimeoutError = () => Object.assign(new Error("[Logix] trialRunModule timed out"), {
   name: "TrialRunTimeoutError"
 });
-var awaitFiberExitWithTimeout = (fiber, timeoutMs) => import_effect32.Effect.gen(function* () {
+var awaitFiberExitWithTimeout = (fiber, timeoutMs) => import_effect35.Effect.gen(function* () {
   const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
   const start = hasTimeout ? Date.now() : 0;
   while (true) {
-    const exitOpt = yield* import_effect32.Fiber.poll(fiber);
-    if (import_effect32.Option.isSome(exitOpt)) {
+    const exitOpt = yield* import_effect35.Fiber.poll(fiber);
+    if (import_effect35.Option.isSome(exitOpt)) {
       return exitOpt.value;
     }
     if (hasTimeout) {
       const elapsedMs = Date.now() - start;
       if (elapsedMs >= timeoutMs) {
-        yield* import_effect32.Fiber.interruptFork(fiber);
-        return import_effect32.Exit.fail(makeTrialRunTimeoutError());
+        yield* import_effect35.Fiber.interruptFork(fiber);
+        return import_effect35.Exit.fail(makeTrialRunTimeoutError());
       }
     }
-    yield* import_effect32.Effect.promise(() => new Promise((r) => setTimeout(r, 1)));
+    yield* import_effect35.Effect.promise(() => new Promise((r) => setTimeout(r, 1)));
   }
 });
-var trialRunModule = (root, options) => import_effect32.Effect.gen(function* () {
+var trialRunModule = (root, options) => import_effect35.Effect.gen(function* () {
   const rootImpl = resolveRootImpl(root);
   const session = makeRunSession({
     runId: options?.runId,
@@ -5625,9 +6923,9 @@ var trialRunModule = (root, options) => import_effect32.Effect.gen(function* ()
     config: buildEnvConfig,
     configProvider: options?.buildEnv?.configProvider
   });
-  const trialLayer = import_effect32.Layer.mergeAll(
+  const trialLayer = import_effect35.Layer.mergeAll(
     buildEnvLayer,
-    options?.layer ?? import_effect32.Layer.empty,
+    options?.layer ?? import_effect35.Layer.empty,
     sessionLayer,
     collectorLayer,
     diagnosticsLayer,
@@ -5647,7 +6945,7 @@ var trialRunModule = (root, options) => import_effect32.Effect.gen(function* ()
   let kernelImplementationRef;
   let runtimeServicesEvidence;
   let instanceId;
-  if (import_effect32.Exit.isSuccess(bootExit)) {
+  if (import_effect35.Exit.isSuccess(bootExit)) {
     const moduleRuntime = bootExit.value;
     instanceId = typeof moduleRuntime?.instanceId === "string" && moduleRuntime.instanceId.length > 0 ? moduleRuntime.instanceId : void 0;
     kernel.setInstanceId(instanceId);
@@ -5664,8 +6962,8 @@ var trialRunModule = (root, options) => import_effect32.Effect.gen(function* ()
       }
     }
   } else {
-    const failure = import_effect32.Cause.failureOption(bootExit.cause);
-    if (import_effect32.Option.isSome(failure)) {
+    const failure = import_effect35.Cause.failureOption(bootExit.cause);
+    if (import_effect35.Option.isSome(failure)) {
       const err = failure.value;
       const instanceIdFromErr = typeof err?.instanceId === "string" ? err.instanceId : void 0;
       if (instanceIdFromErr && instanceIdFromErr.length > 0) {
@@ -5673,7 +6971,7 @@ var trialRunModule = (root, options) => import_effect32.Effect.gen(function* ()
       }
     }
   }
-  const closeExit = yield* import_effect32.Effect.exit(
+  const closeExit = yield* import_effect35.Effect.exit(
     kernel.close({
       timeoutMs: typeof options?.closeScopeTimeout === "number" && Number.isFinite(options.closeScopeTimeout) && options.closeScopeTimeout > 0 ? options.closeScopeTimeout : 1e3
     })
@@ -5698,16 +6996,16 @@ var trialRunModule = (root, options) => import_effect32.Effect.gen(function* ()
       return void 0;
     }
   })();
-  let ok = import_effect32.Exit.isSuccess(bootExit) && import_effect32.Exit.isSuccess(closeExit);
+  let ok = import_effect35.Exit.isSuccess(bootExit) && import_effect35.Exit.isSuccess(closeExit);
   let error;
   let summary;
-  const depsFromBootFailure = import_effect32.Exit.isFailure(bootExit) ? parseMissingDependencyFromCause(bootExit.cause) : { missingServices: [], missingConfigKeys: [] };
+  const depsFromBootFailure = import_effect35.Exit.isFailure(bootExit) ? parseMissingDependencyFromCause(bootExit.cause) : { missingServices: [], missingConfigKeys: [] };
   const missingServices = depsFromBootFailure.missingServices;
   const missingConfigKeys = depsFromBootFailure.missingConfigKeys;
-  const closeError = import_effect32.Exit.isFailure(closeExit) ? import_effect32.Option.getOrUndefined(import_effect32.Cause.dieOption(closeExit.cause)) : void 0;
-  if (!import_effect32.Exit.isSuccess(bootExit)) {
-    const failure = import_effect32.Option.getOrUndefined(import_effect32.Cause.failureOption(bootExit.cause));
-    const defect = import_effect32.Option.getOrUndefined(import_effect32.Cause.dieOption(bootExit.cause));
+  const closeError = import_effect35.Exit.isFailure(closeExit) ? import_effect35.Option.getOrUndefined(import_effect35.Cause.dieOption(closeExit.cause)) : void 0;
+  if (!import_effect35.Exit.isSuccess(bootExit)) {
+    const failure = import_effect35.Option.getOrUndefined(import_effect35.Cause.failureOption(bootExit.cause));
+    const defect = import_effect35.Option.getOrUndefined(import_effect35.Cause.dieOption(bootExit.cause));
     const base = failure ?? defect ?? bootExit.cause;
     if (missingServices.length > 0 || missingConfigKeys.length > 0) {
       ok = false;
@@ -5728,9 +7026,9 @@ var trialRunModule = (root, options) => import_effect32.Effect.gen(function* ()
       error = toErrorSummaryWithCode2(base, "RuntimeFailure");
     }
   }
-  if (import_effect32.Exit.isFailure(closeExit)) {
-    const died = import_effect32.Option.getOrUndefined(import_effect32.Cause.dieOption(closeExit.cause));
-    const failure = import_effect32.Option.getOrUndefined(import_effect32.Cause.failureOption(closeExit.cause));
+  if (import_effect35.Exit.isFailure(closeExit)) {
+    const died = import_effect35.Option.getOrUndefined(import_effect35.Cause.dieOption(closeExit.cause));
+    const failure = import_effect35.Option.getOrUndefined(import_effect35.Cause.failureOption(closeExit.cause));
     const base = died ?? failure ?? closeExit.cause;
     const closeErrorSummary = (() => {
       const tag = isRecord6(base) ? base._tag : void 0;
@@ -5810,7 +7108,7 @@ var defaultHost2 = () => {
   if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
   return "node";
 };
-var trialRun = (program, options) => import_effect33.Effect.gen(function* () {
+var trialRun = (program, options) => import_effect36.Effect.gen(function* () {
   const session = makeRunSession({
     runId: options?.runId,
     source: options?.source ?? { host: defaultHost2(), label: "trial-run" },
@@ -5827,12 +7125,12 @@ var trialRun = (program, options) => import_effect33.Effect.gen(function* () {
   const convergeLayer = appendConvergeStaticIrCollectors([convergeCollector]);
   const collectorLayer = evidenceCollectorLayer(collector);
   const sessionLayer = runSessionLayer(session);
-  const overridesLayer = options?.runtimeServicesInstanceOverrides != null ? import_effect33.Layer.succeed(
+  const overridesLayer = options?.runtimeServicesInstanceOverrides != null ? import_effect36.Layer.succeed(
     RuntimeServicesInstanceOverridesTag,
     options.runtimeServicesInstanceOverrides
-  ) : import_effect33.Layer.empty;
-  const trialLayer = import_effect33.Layer.mergeAll(
-    options?.layer ?? import_effect33.Layer.empty,
+  ) : import_effect36.Layer.empty;
+  const trialLayer = import_effect36.Layer.mergeAll(
+    options?.layer ?? import_effect36.Layer.empty,
     sessionLayer,
     collectorLayer,
     overridesLayer,
@@ -5840,9 +7138,9 @@ var trialRun = (program, options) => import_effect33.Effect.gen(function* () {
     sinksLayer,
     convergeLayer
   );
-  const scope = yield* import_effect33.Scope.make();
-  const exit = yield* import_effect33.Effect.exit(program).pipe(import_effect33.Effect.provideService(import_effect33.Scope.Scope, scope), import_effect33.Effect.provide(trialLayer));
-  yield* import_effect33.Scope.close(scope, exit);
+  const scope = yield* import_effect36.Scope.make();
+  const exit = yield* import_effect36.Effect.exit(program).pipe(import_effect36.Effect.provideService(import_effect36.Scope.Scope, scope), import_effect36.Effect.provide(trialLayer));
+  yield* import_effect36.Scope.close(scope, exit);
   const evidence = collector.exportEvidencePackage({
     maxEvents: options?.maxEvents
   });