@logixjs/react 0.1.0 → 1.0.0

package/dist/{chunk-UFFCJGSZ.js → chunk-E3ZXST5F.js}

@@ -5,7 +5,7 @@ import {
   isDevEnv,
   stableHash,
   useLayerBinding
-} from "./chunk-2WFULYPJ.js";
+} from "./chunk-L7KTYBXN.js";
 
 // src/internal/hooks/useRuntime.ts
 import { useContext, useEffect, useMemo, useRef } from "react";
@@ -138,12 +138,12 @@ var shallow = (previous, next) => {
 // src/internal/hooks/useSelector.ts
 import { useContext as useContext3, useEffect as useEffect3, useMemo as useMemo3 } from "react";
 import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector";
-import * as Logix2 from "@logixjs/core";
+import * as Logix4 from "@logixjs/core";
 
 // src/internal/hooks/useModuleRuntime.ts
-import { useEffect as useEffect2, useMemo as useMemo2, useContext as useContext2 } from "react";
-import * as Logix from "@logixjs/core";
-import { Scope } from "effect";
+import { useEffect as useEffect2, useMemo as useMemo2, useContext as useContext2, useRef as useRef2 } from "react";
+import * as Logix2 from "@logixjs/core";
+import { Effect as Effect2, Scope } from "effect";
 
 // src/internal/store/ModuleRef.ts
 var isModuleRef = (value) => typeof value === "object" && value !== null && "runtime" in value && "actions" in value && "dispatch" in value;
@@ -234,11 +234,26 @@ var applyHandleExtend = (tag, runtime, base) => {
   return { ...base, ...next };
 };
 
+// src/internal/provider/runtimeDebugBridge.ts
+import { Effect } from "effect";
+import * as Logix from "@logixjs/core";
+var readRuntimeDiagnosticsLevel = (runtime) => {
+  try {
+    return runtime.runSync(Effect.service(Logix.Debug.internal.currentDiagnosticsLevel).pipe(Effect.orDie));
+  } catch {
+    return isDevEnv() ? "light" : "off";
+  }
+};
+var emitRuntimeDebugEventBestEffort = (runtime, event) => {
+  runtime.runFork(event);
+};
+
 // src/internal/hooks/useModuleRuntime.ts
 var isModuleRuntime = (value) => typeof value === "object" && value !== null && "dispatch" in value && "getState" in value;
 function useModuleRuntime(handle) {
   const runtime = useRuntime();
   const runtimeContext = useContext2(RuntimeContext);
+  const moduleTagResolveTraceRef = useRef2(void 0);
   if (!runtimeContext) {
     throw new RuntimeProviderNotFoundError("useModuleRuntime");
   }
@@ -259,87 +274,117 @@ function useModuleRuntime(handle) {
     const preloadKey = runtimeContext.policy.preload?.keysByTagId.get(tokenId);
     const key = preloadKey ?? `tag:${tokenId}`;
     const mode = runtimeContext.policy.moduleTagMode;
-    const factory = (scope) => tag.pipe(Scope.extend(scope));
-    return mode === "suspend" ? cache.read(key, factory, void 0, tokenId, {
+    const startedAtMs = performance.now();
+    const factory = (scope) => Scope.provide(scope)(Effect2.service(tag).pipe(Effect2.orDie));
+    const resolvedRuntime = mode === "suspend" ? cache.read(key, factory, void 0, tokenId, {
       entrypoint: "react.useModuleRuntime",
       policyMode: runtimeContext.policy.mode,
-      yield: runtimeContext.policy.yield
+      yield: runtimeContext.policy.yield,
+      optimisticSyncBudgetMs: runtimeContext.policy.syncBudgetMs
     }) : cache.readSync(key, factory, void 0, tokenId, {
       entrypoint: "react.useModuleRuntime",
       policyMode: runtimeContext.policy.mode,
       warnSyncBlockingThresholdMs: 5
     });
+    moduleTagResolveTraceRef.current = {
+      tokenId,
+      durationMs: Math.round((performance.now() - startedAtMs) * 100) / 100,
+      cacheMode: mode
+    };
+    return resolvedRuntime;
   }, [cache, runtimeContext.policy, handle]);
   useEffect2(() => {
     if (!isTagHandle) {
       return;
     }
-    if (!isDevEnv() && !Logix.Debug.isDevtoolsEnabled()) {
+    const diagnosticsLevel = readRuntimeDiagnosticsLevel(runtime);
+    if (diagnosticsLevel === "off") {
       return;
     }
     const tokenId = handle?.id ?? "ModuleTag";
-    const effect = Logix.Debug.record({
+    const trace = moduleTagResolveTraceRef.current;
+    const effect = Logix2.Debug.record({
       type: "trace:react.moduleTag.resolve",
       moduleId: resolved.moduleId,
       instanceId: resolved.instanceId,
       data: {
         mode: runtimeContext.policy.moduleTagMode,
         tokenId,
-        yieldStrategy: runtimeContext.policy.yield.strategy
+        yieldStrategy: runtimeContext.policy.yield.strategy,
+        durationMs: trace?.durationMs,
+        cacheMode: trace?.cacheMode ?? runtimeContext.policy.moduleTagMode
       }
     });
-    runtime.runFork(effect);
+    emitRuntimeDebugEventBestEffort(runtime, effect);
   }, [runtime, runtimeContext.policy, resolved, handle, isTagHandle]);
   return resolved;
 }
 
-// src/internal/store/ModuleRuntimeExternalStore.ts
-import { Effect as Effect2, Fiber, Stream } from "effect";
+// src/internal/store/RuntimeExternalStore.ts
+import * as Logix3 from "@logixjs/core";
+import { Fiber, Stream } from "effect";
 var storesByRuntime = /* @__PURE__ */ new WeakMap();
 var getStoreMapForRuntime = (runtime) => {
   const cached = storesByRuntime.get(runtime);
   if (cached) return cached;
-  const next = /* @__PURE__ */ new WeakMap();
+  const next = /* @__PURE__ */ new Map();
   storesByRuntime.set(runtime, next);
   return next;
 };
-var getModuleRuntimeExternalStore = (runtime, moduleRuntime, options) => {
-  const byModule = getStoreMapForRuntime(runtime);
-  const cached = byModule.get(moduleRuntime);
+var makeModuleInstanceKey = (moduleId, instanceId) => `${moduleId}::${instanceId}`;
+var makeReadQueryTopicKey = (moduleInstanceKey, selectorId) => `${moduleInstanceKey}::rq:${selectorId}`;
+var getRuntimeStore = (runtime) => Logix3.InternalContracts.getRuntimeStore(runtime);
+var getHostScheduler = (runtime) => Logix3.InternalContracts.getHostScheduler(runtime);
+var getOrCreateStore = (runtime, topicKey, make) => {
+  const map = getStoreMapForRuntime(runtime);
+  const cached = map.get(topicKey);
   if (cached) {
     return cached;
   }
-  let currentState;
+  const created = make();
+  map.set(topicKey, created);
+  return created;
+};
+var removeStore = (runtime, topicKey) => {
+  const map = storesByRuntime.get(runtime);
+  if (!map) return;
+  map.delete(topicKey);
+};
+var makeTopicExternalStore = (args) => {
+  const { runtime, runtimeStore, topicKey } = args;
+  const hostScheduler = getHostScheduler(runtime);
+  let currentVersion;
+  let hasSnapshot = false;
+  let currentSnapshot;
   const listeners = /* @__PURE__ */ new Set();
-  const lowPriorityDelayMs = options?.lowPriorityDelayMs ?? 16;
-  const lowPriorityMaxDelayMs = options?.lowPriorityMaxDelayMs ?? 50;
+  let unsubscribeFromRuntimeStore;
+  let teardownScheduled = false;
+  let teardownToken = 0;
+  const lowPriorityDelayMs = args.options?.lowPriorityDelayMs ?? 16;
+  const lowPriorityMaxDelayMs = args.options?.lowPriorityMaxDelayMs ?? 50;
   let notifyScheduled = false;
   let notifyScheduledLow = false;
-  let lowTimeoutId;
-  let lowMaxTimeoutId;
-  let lowRafId;
+  let lowCancelDelay;
+  let lowCancelMaxDelay;
+  let lowCancelRaf;
   const cancelLow = () => {
     if (!notifyScheduledLow) return;
     notifyScheduledLow = false;
-    if (lowTimeoutId != null) {
-      clearTimeout(lowTimeoutId);
-      lowTimeoutId = void 0;
-    }
-    if (lowMaxTimeoutId != null) {
-      clearTimeout(lowMaxTimeoutId);
-      lowMaxTimeoutId = void 0;
-    }
-    const cancel = globalThis.cancelAnimationFrame;
-    if (cancel && typeof lowRafId === "number") {
-      cancel(lowRafId);
-      lowRafId = void 0;
-    }
+    lowCancelDelay?.();
+    lowCancelDelay = void 0;
+    lowCancelMaxDelay?.();
+    lowCancelMaxDelay = void 0;
+    lowCancelRaf?.();
+    lowCancelRaf = void 0;
   };
   const flushNotify = () => {
     notifyScheduled = false;
     cancelLow();
     for (const listener of listeners) {
-      listener();
+      try {
+        listener();
+      } catch {
+      }
     }
   };
   const scheduleNotify = (priority) => {
@@ -351,209 +396,154 @@ var getModuleRuntimeExternalStore = (runtime, moduleRuntime, options) => {
         if (!notifyScheduledLow) return;
         flushNotify();
       };
-      const raf = globalThis.requestAnimationFrame;
-      if (raf) {
-        lowRafId = raf(flush);
+      const scheduleRaf = () => {
+        if (!notifyScheduledLow) return;
+        lowCancelRaf = hostScheduler.scheduleAnimationFrame(flush);
+      };
+      if (lowPriorityDelayMs <= 0) {
+        scheduleRaf();
       } else {
-        lowTimeoutId = setTimeout(flush, lowPriorityDelayMs);
+        lowCancelDelay = hostScheduler.scheduleTimeout(lowPriorityDelayMs, scheduleRaf);
       }
-      lowMaxTimeoutId = setTimeout(flush, lowPriorityMaxDelayMs);
+      lowCancelMaxDelay = hostScheduler.scheduleTimeout(lowPriorityMaxDelayMs, flush);
       return;
     }
     cancelLow();
     if (notifyScheduled) return;
     notifyScheduled = true;
-    queueMicrotask(flushNotify);
+    hostScheduler.scheduleMicrotask(flushNotify);
+  };
+  const onRuntimeStoreChange = () => {
+    try {
+      scheduleNotify(runtimeStore.getTopicPriority(topicKey));
+    } catch {
+    }
   };
-  let fiber;
   const ensureSubscription = () => {
-    if (fiber) return;
-    fiber = runtime.runFork(
-      Stream.runForEach(
-        moduleRuntime.changesWithMeta((state) => state),
-        ({ value: state, meta }) => Effect2.sync(() => {
-          currentState = state;
-          scheduleNotify(meta.priority);
-        })
-      )
-    );
+    if (unsubscribeFromRuntimeStore) return;
+    unsubscribeFromRuntimeStore = runtimeStore.subscribeTopic(topicKey, onRuntimeStoreChange);
   };
   const refreshSnapshotIfStale = () => {
-    if (currentState === void 0) {
-      return;
-    }
+    if (!hasSnapshot) return;
     try {
-      const latest = runtime.runSync(moduleRuntime.getState);
-      if (currentState === void 0 || !Object.is(currentState, latest)) {
-        currentState = latest;
-        scheduleNotify("normal");
+      const version = runtimeStore.getTopicVersion(topicKey);
+      if (currentVersion !== version) {
+        scheduleNotify(runtimeStore.getTopicPriority(topicKey));
       }
     } catch {
     }
   };
   const getSnapshot = () => {
-    if (currentState !== void 0) return currentState;
-    currentState = runtime.runSync(moduleRuntime.getState);
-    return currentState;
-  };
-  const subscribe = (listener) => {
-    listeners.add(listener);
-    ensureSubscription();
-    refreshSnapshotIfStale();
-    return () => {
-      listeners.delete(listener);
-      if (listeners.size > 0) return;
-      const running = fiber;
-      if (!running) return;
-      fiber = void 0;
-      cancelLow();
-      runtime.runFork(Fiber.interrupt(running));
-    };
+    const version = runtimeStore.getTopicVersion(topicKey);
+    if (hasSnapshot && currentVersion === version) {
+      return currentSnapshot;
+    }
+    const next = args.readSnapshot();
+    currentVersion = version;
+    hasSnapshot = true;
+    currentSnapshot = next;
+    return next;
   };
-  const store = { getSnapshot, subscribe };
-  byModule.set(moduleRuntime, store);
-  return store;
-};
-
-// src/internal/store/ModuleRuntimeSelectorExternalStore.ts
-import { Effect as Effect3, Fiber as Fiber2, Stream as Stream2 } from "effect";
-var storesByRuntime2 = /* @__PURE__ */ new WeakMap();
-var getStoreMapForRuntime2 = (runtime) => {
-  const cached = storesByRuntime2.get(runtime);
-  if (cached) return cached;
-  const next = /* @__PURE__ */ new WeakMap();
-  storesByRuntime2.set(runtime, next);
-  return next;
-};
-var getOrCreateSelectorMapForModule = (byModule, moduleRuntime) => {
-  const cached = byModule.get(moduleRuntime);
-  if (cached) return cached;
-  const next = /* @__PURE__ */ new Map();
-  byModule.set(moduleRuntime, next);
-  return next;
-};
-var equalsValue = (readQuery, a, b) => {
-  if (readQuery.equalsKind === "custom" && typeof readQuery.equals === "function") {
-    return readQuery.equals(a, b);
-  }
-  if (readQuery.equalsKind === "shallowStruct") {
-    return shallow(a, b);
-  }
-  return Object.is(a, b);
-};
-var getModuleRuntimeSelectorExternalStore = (runtime, moduleRuntime, selectorReadQuery, options) => {
-  const byModule = getStoreMapForRuntime2(runtime);
-  const bySelector = getOrCreateSelectorMapForModule(byModule, moduleRuntime);
-  const cached = bySelector.get(selectorReadQuery.selectorId);
-  if (cached) {
-    return cached;
-  }
-  let currentValue;
-  const listeners = /* @__PURE__ */ new Set();
-  const lowPriorityDelayMs = options?.lowPriorityDelayMs ?? 16;
-  const lowPriorityMaxDelayMs = options?.lowPriorityMaxDelayMs ?? 50;
-  let notifyScheduled = false;
-  let notifyScheduledLow = false;
-  let lowTimeoutId;
-  let lowMaxTimeoutId;
-  let lowRafId;
-  const cancelLow = () => {
-    if (!notifyScheduledLow) return;
-    notifyScheduledLow = false;
-    if (lowTimeoutId != null) {
-      clearTimeout(lowTimeoutId);
-      lowTimeoutId = void 0;
-    }
-    if (lowMaxTimeoutId != null) {
-      clearTimeout(lowMaxTimeoutId);
-      lowMaxTimeoutId = void 0;
-    }
-    const cancel = globalThis.cancelAnimationFrame;
-    if (cancel && typeof lowRafId === "number") {
-      cancel(lowRafId);
-      lowRafId = void 0;
-    }
+  const cancelScheduledTeardown = () => {
+    if (!teardownScheduled) return;
+    teardownScheduled = false;
+    teardownToken += 1;
   };
-  const flushNotify = () => {
-    notifyScheduled = false;
-    cancelLow();
-    for (const listener of listeners) {
-      listener();
-    }
-  };
-  const scheduleNotify = (priority) => {
-    if (priority === "low") {
-      if (notifyScheduled) return;
-      if (notifyScheduledLow) return;
-      notifyScheduledLow = true;
-      const flush = () => {
-        if (!notifyScheduledLow) return;
-        flushNotify();
-      };
-      const raf = globalThis.requestAnimationFrame;
-      if (raf) {
-        lowRafId = raf(flush);
-      } else {
-        lowTimeoutId = setTimeout(flush, lowPriorityDelayMs);
-      }
-      lowMaxTimeoutId = setTimeout(flush, lowPriorityMaxDelayMs);
-      return;
+  const finalizeTeardown = () => {
+    if (listeners.size > 0) return;
+    try {
+      args.onLastListener?.();
+    } catch {
     }
+    const unsub = unsubscribeFromRuntimeStore;
+    unsubscribeFromRuntimeStore = void 0;
     cancelLow();
-    if (notifyScheduled) return;
-    notifyScheduled = true;
-    queueMicrotask(flushNotify);
-  };
-  let fiber;
-  const ensureSubscription = () => {
-    if (fiber) return;
-    fiber = runtime.runFork(
-      Stream2.runForEach(
-        moduleRuntime.changesReadQueryWithMeta(selectorReadQuery),
-        ({ value, meta }) => Effect3.sync(() => {
-          currentValue = value;
-          scheduleNotify(meta.priority);
-        })
-      )
-    );
-  };
-  const refreshSnapshotIfStale = () => {
-    if (currentValue === void 0) {
-      return;
-    }
     try {
-      const state = runtime.runSync(moduleRuntime.getState);
-      const next = selectorReadQuery.select(state);
-      if (currentValue === void 0 || !equalsValue(selectorReadQuery, currentValue, next)) {
-        currentValue = next;
-        scheduleNotify("normal");
-      }
+      unsub?.();
     } catch {
     }
+    removeStore(runtime, topicKey);
   };
-  const getSnapshot = () => {
-    if (currentValue !== void 0) return currentValue;
-    const state = runtime.runSync(moduleRuntime.getState);
-    currentValue = selectorReadQuery.select(state);
-    return currentValue;
+  const scheduleTeardown = () => {
+    if (teardownScheduled) return;
+    teardownScheduled = true;
+    const token = ++teardownToken;
+    hostScheduler.scheduleMicrotask(() => {
+      if (!teardownScheduled || token !== teardownToken) return;
+      teardownScheduled = false;
+      finalizeTeardown();
+    });
   };
   const subscribe = (listener) => {
+    cancelScheduledTeardown();
+    const isFirst = listeners.size === 0;
     listeners.add(listener);
     ensureSubscription();
     refreshSnapshotIfStale();
+    if (isFirst) {
+      try {
+        args.onFirstListener?.();
+      } catch {
+      }
+    }
     return () => {
       listeners.delete(listener);
       if (listeners.size > 0) return;
-      const running = fiber;
-      if (!running) return;
-      fiber = void 0;
-      cancelLow();
-      runtime.runFork(Fiber2.interrupt(running));
+      scheduleTeardown();
     };
   };
-  const store = { getSnapshot, subscribe };
-  bySelector.set(selectorReadQuery.selectorId, store);
-  return store;
+  return { getSnapshot, getServerSnapshot: getSnapshot, subscribe };
+};
+var getRuntimeModuleExternalStore = (runtime, moduleRuntime, options) => {
+  const moduleInstanceKey = makeModuleInstanceKey(moduleRuntime.moduleId, moduleRuntime.instanceId);
+  const runtimeStore = getRuntimeStore(runtime);
+  return getOrCreateStore(
+    runtime,
+    moduleInstanceKey,
+    () => makeTopicExternalStore({
+      runtime,
+      runtimeStore,
+      topicKey: moduleInstanceKey,
+      readSnapshot: () => {
+        const state = runtimeStore.getModuleState(moduleInstanceKey);
+        if (state !== void 0) return state;
+        return runtime.runSync(moduleRuntime.getState);
+      },
+      options
+    })
+  );
+};
+var getRuntimeReadQueryExternalStore = (runtime, moduleRuntime, selectorReadQuery, options) => {
+  const moduleInstanceKey = makeModuleInstanceKey(moduleRuntime.moduleId, moduleRuntime.instanceId);
+  const topicKey = makeReadQueryTopicKey(moduleInstanceKey, selectorReadQuery.selectorId);
+  const runtimeStore = getRuntimeStore(runtime);
+  let readQueryDrainFiber;
+  return getOrCreateStore(
+    runtime,
+    topicKey,
+    () => makeTopicExternalStore({
+      runtime,
+      runtimeStore,
+      topicKey,
+      readSnapshot: () => {
+        const state = runtimeStore.getModuleState(moduleInstanceKey);
+        const current = state ?? runtime.runSync(moduleRuntime.getState);
+        return selectorReadQuery.select(current);
+      },
+      options,
+      onFirstListener: () => {
+        if (readQueryDrainFiber) return;
+        const effect = Stream.runDrain(moduleRuntime.changesReadQueryWithMeta(selectorReadQuery));
+        readQueryDrainFiber = runtime.runFork(effect);
+      },
+      onLastListener: () => {
+        const fiber = readQueryDrainFiber;
+        if (!fiber) return;
+        readQueryDrainFiber = void 0;
+        runtime.runFork(Fiber.interrupt(fiber));
+      }
+    })
+  );
 };
 
 // src/internal/hooks/useSelector.ts
@@ -566,7 +556,7 @@ function useSelector(handle, selector, equalityFn) {
   const moduleRuntime = useModuleRuntime(handle);
   const actualSelector = selector ?? ((state) => state);
   const selectorReadQuery = useMemo3(
-    () => typeof selector === "function" ? Logix2.ReadQuery.compile(selector) : void 0,
+    () => typeof selector === "function" ? Logix4.ReadQuery.compile(selector) : void 0,
     [selector]
   );
   const actualEqualityFn = useMemo3(() => {
@@ -574,17 +564,12 @@ function useSelector(handle, selector, equalityFn) {
     if (typeof selector !== "function") return Object.is;
     return selectorReadQuery?.equalsKind === "shallowStruct" ? shallow : Object.is;
   }, [equalityFn, selector, selectorReadQuery?.equalsKind]);
-  const useStaticLane = typeof selector === "function" && selectorReadQuery?.lane === "static";
+  const selectorTopicEligible = typeof selector === "function" && selectorReadQuery?.lane === "static" && selectorReadQuery.readsDigest != null && selectorReadQuery.fallbackReason == null;
   const store = useMemo3(
-    () => useStaticLane && selectorReadQuery ? getModuleRuntimeSelectorExternalStore(
-      runtime,
-      moduleRuntime,
-      selectorReadQuery,
-      {
-        lowPriorityDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityDelayMs,
-        lowPriorityMaxDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityMaxDelayMs
-      }
-    ) : getModuleRuntimeExternalStore(
+    () => selectorTopicEligible && selectorReadQuery ? getRuntimeReadQueryExternalStore(runtime, moduleRuntime, selectorReadQuery, {
+      lowPriorityDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityDelayMs,
+      lowPriorityMaxDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityMaxDelayMs
+    }) : getRuntimeModuleExternalStore(
       runtime,
       moduleRuntime,
       {
@@ -598,18 +583,18 @@ function useSelector(handle, selector, equalityFn) {
       runtimeContext.reactConfigSnapshot.lowPriorityDelayMs,
       runtimeContext.reactConfigSnapshot.lowPriorityMaxDelayMs,
       selectorReadQuery,
-      useStaticLane
+      selectorTopicEligible
     ]
   );
   const selected = useSyncExternalStoreWithSelector(
     store.subscribe,
     store.getSnapshot,
-    store.getSnapshot,
-    useStaticLane ? (snapshot) => snapshot : (snapshot) => actualSelector(snapshot),
+    store.getServerSnapshot ?? store.getSnapshot,
+    selectorTopicEligible ? (snapshot) => snapshot : (snapshot) => actualSelector(snapshot),
     actualEqualityFn
   );
   useEffect3(() => {
-    if (!isDevEnv() && !Logix2.Debug.isDevtoolsEnabled()) {
+    if (!isDevEnv() && !Logix4.Debug.isDevtoolsEnabled()) {
       return;
     }
     const instanceId = moduleRuntime.instanceId;
@@ -625,7 +610,7 @@ function useSelector(handle, selector, equalityFn) {
       const rawDebugKey = meta.debugKey;
       selectorKey = typeof rawDebugKey === "string" && rawDebugKey.length > 0 ? rawDebugKey : typeof selector.name === "string" && selector.name.length > 0 ? selector.name : void 0;
     }
-    const effect = Logix2.Debug.record({
+    const effect = Logix4.Debug.record({
       type: "trace:react-selector",
       moduleId: moduleRuntime.moduleId,
       instanceId,
@@ -649,11 +634,11 @@ function useSelector(handle, selector, equalityFn) {
 
 // src/internal/hooks/useModule.ts
 import React2 from "react";
-import * as Logix4 from "@logixjs/core";
-import { Context, Effect as Effect4, Layer as Layer2 } from "effect";
+import * as Logix6 from "@logixjs/core";
+import { Effect as Effect4, Layer as Layer2, ServiceMap } from "effect";
 
 // src/internal/store/resolveImportedModuleRef.ts
-import * as Logix3 from "@logixjs/core";
+import * as Logix5 from "@logixjs/core";
 var getOrCreateWeakMap = (map, key, make) => {
   const cached = map.get(key);
   if (cached) return cached;
@@ -677,7 +662,7 @@ var resolveImportedModuleRef = (runtime, parentRuntime, module) => {
   if (cached) {
     return cached;
   }
-  const importsScope = Logix3.InternalContracts.getImportsScope(parentRuntime);
+  const importsScope = Logix5.InternalContracts.getImportsScope(parentRuntime);
   const childRuntime = importsScope.get(module);
   if (childRuntime) {
     const dispatch = Object.assign(
@@ -763,8 +748,8 @@ var useStableId = () => {
 
 // src/internal/hooks/useModule.ts
 var isModuleImpl = (handle) => Boolean(handle) && typeof handle === "object" && handle._tag === "ModuleImpl";
-var isModule = (handle) => Logix4.Module.hasImpl(handle);
-var isModuleDef = (handle) => Logix4.Module.is(handle) && handle._kind === "ModuleDef";
+var isModule = (handle) => Logix6.Module.hasImpl(handle);
+var isModuleDef = (handle) => Logix6.Module.is(handle) && handle._kind === "ModuleDef";
 function useModule(handle, selectorOrOptions, equalityFn) {
   const runtimeBase = useRuntime();
   const runtimeContext = React2.useContext(RuntimeContext);
@@ -788,6 +773,7 @@ function useModule(handle, selectorOrOptions, equalityFn) {
     }
   }
   let runtime;
+  const moduleImplResolveTraceRef = React2.useRef(void 0);
   if (isModuleImpl(normalizedHandle)) {
     const cache = React2.useMemo(
       () => getModuleCache(runtimeBase, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion),
@@ -816,9 +802,9 @@ function useModule(handle, selectorOrOptions, equalityFn) {
     const key = depsHash ? `${baseKey}:${depsHash}` : baseKey;
     const ownerId = moduleId;
     const baseFactory = React2.useMemo(
-      () => (scope) => Layer2.buildWithScope(normalizedHandle.layer, scope).pipe(
+      () => (scope) => Layer2.buildWithScope(Layer2.fresh(normalizedHandle.layer), scope).pipe(
         Effect4.map(
-          (context) => Context.get(context, normalizedHandle.module)
+          (context) => ServiceMap.get(context, normalizedHandle.module)
         )
       ),
       [normalizedHandle]
@@ -828,26 +814,56 @@ function useModule(handle, selectorOrOptions, equalityFn) {
         return baseFactory;
       }
       return (scope) => baseFactory(scope).pipe(
-        Effect4.timeoutFail({
-          duration: initTimeoutMs,
-          onTimeout: () => new Error(`[useModule] Module "${ownerId}" initialization timed out after ${initTimeoutMs}ms`)
-        })
+        Effect4.timeoutOption(initTimeoutMs),
+        Effect4.flatMap(
+          (maybe) => maybe._tag === "Some" ? Effect4.succeed(maybe.value) : Effect4.die(new Error(`[useModule] Module "${ownerId}" initialization timed out after ${initTimeoutMs}ms`))
+        )
       );
     }, [baseFactory, suspend, initTimeoutMs, ownerId]);
+    const moduleResolveStartedAt = performance.now();
     const moduleRuntime = suspend ? cache.read(key, factory, gcTime, ownerId, {
       entrypoint: "react.useModule",
       policyMode: runtimeContext.policy.mode,
-      yield: runtimeContext.policy.yield
+      yield: runtimeContext.policy.yield,
+      optimisticSyncBudgetMs: runtimeContext.policy.syncBudgetMs
     }) : cache.readSync(key, factory, gcTime, ownerId, {
       entrypoint: "react.useModule",
       policyMode: runtimeContext.policy.mode,
       warnSyncBlockingThresholdMs: 5
     });
+    moduleImplResolveTraceRef.current = {
+      moduleId,
+      cacheMode: suspend ? "suspend" : "sync",
+      durationMs: Math.round((performance.now() - moduleResolveStartedAt) * 100) / 100
+    };
     React2.useEffect(() => cache.retain(key), [cache, key]);
     runtime = moduleRuntime;
   } else {
     runtime = useModuleRuntime(normalizedHandle);
   }
+  React2.useEffect(() => {
+    if (!isModuleImpl(normalizedHandle)) {
+      return;
+    }
+    const diagnosticsLevel = readRuntimeDiagnosticsLevel(runtimeBase);
+    if (diagnosticsLevel === "off") {
+      return;
+    }
+    const trace = moduleImplResolveTraceRef.current;
+    if (!trace) {
+      return;
+    }
+    const effect = Logix6.Debug.record({
+      type: "trace:react.moduleImpl.resolve",
+      moduleId: trace.moduleId,
+      instanceId: runtime.instanceId,
+      data: {
+        cacheMode: trace.cacheMode,
+        durationMs: trace.durationMs
+      }
+    });
+    emitRuntimeDebugEventBestEffort(runtimeBase, effect);
+  }, [runtimeBase, runtime, normalizedHandle]);
   React2.useEffect(() => {
     if (!isModuleImpl(normalizedHandle)) {
       return;
@@ -857,22 +873,22 @@ function useModule(handle, selectorOrOptions, equalityFn) {
     if (!label) {
       return;
     }
-    const effect = Logix4.Debug.record({
+    const effect = Logix6.Debug.record({
       type: "trace:instanceLabel",
       moduleId: normalizedHandle.module.id,
       instanceId: runtime.instanceId,
       data: { label }
     });
-    runtimeBase.runFork(effect);
+    emitRuntimeDebugEventBestEffort(runtimeBase, effect);
   }, [runtimeBase, runtime, normalizedHandle, options]);
   React2.useEffect(() => {
-    if (!isDevEnv() && !Logix4.Debug.isDevtoolsEnabled()) {
+    if (!isDevEnv() && !Logix6.Debug.isDevtoolsEnabled()) {
       return;
     }
     if (!runtime.instanceId) {
       return;
     }
-    const effect = Logix4.Debug.record({
+    const effect = Logix6.Debug.record({
       type: "trace:react-render",
       moduleId: runtime.moduleId,
       instanceId: runtime.instanceId,
@@ -882,7 +898,7 @@ function useModule(handle, selectorOrOptions, equalityFn) {
       }
     });
     runtimeBase.runFork(effect);
-  }, [runtimeBase, runtime]);
+  });
   if (selector) {
     if (isModuleImpl(normalizedHandle)) {
       return useSelector(runtime, selector, equalityFn);