@logixjs/react 0.1.1 → 1.0.1

package/dist/ModuleScope.cjs

@@ -34,17 +34,18 @@ __export(ModuleScope_exports, {
 });
 module.exports = __toCommonJS(ModuleScope_exports);
 var import_react10 = __toESM(require("react"), 1);
-var Logix11 = __toESM(require("@logixjs/core"), 1);
+var import_effect11 = require("effect");
+var Logix12 = __toESM(require("@logixjs/core"), 1);
 
 // src/internal/hooks/useModule.ts
 var import_react7 = __toESM(require("react"), 1);
-var Logix8 = __toESM(require("@logixjs/core"), 1);
-var import_effect7 = require("effect");
+var Logix9 = __toESM(require("@logixjs/core"), 1);
+var import_effect8 = require("effect");
 
 // src/internal/hooks/useModuleRuntime.ts
 var import_react4 = require("react");
-var Logix4 = __toESM(require("@logixjs/core"), 1);
-var import_effect5 = require("effect");
+var Logix5 = __toESM(require("@logixjs/core"), 1);
+var import_effect6 = require("effect");
 
 // src/internal/hooks/useRuntime.ts
 var import_react3 = require("react");
@@ -128,14 +129,11 @@ var useLayerBinding = (runtime, layer, enabled, onError) => {
     const newScope = import_effect.Effect.runSync(import_effect.Scope.make());
     const buildEffect = import_effect.Effect.gen(function* () {
       const context = yield* import_effect.Layer.buildWithScope(layer, newScope);
-      const applyEnv = (effect) => import_effect.Effect.mapInputContext(
-        import_effect.Scope.extend(effect, newScope),
-        (parent) => import_effect.Context.merge(parent, context)
-      );
-      const loggers = yield* applyEnv(import_effect.FiberRef.get(import_effect.FiberRef.currentLoggers));
-      const logLevel = yield* applyEnv(import_effect.FiberRef.get(import_effect.FiberRef.currentLogLevel));
+      const applyEnv = (effect) => import_effect.Scope.provide(newScope)(import_effect.Effect.provideServices(effect, context));
+      const loggers = yield* applyEnv(import_effect.Effect.service(import_effect.Logger.CurrentLoggers)).pipe(import_effect.Effect.orDie);
+      const logLevel = yield* applyEnv(import_effect.Effect.service(import_effect.References.MinimumLogLevel)).pipe(import_effect.Effect.orDie);
       const debugSinks = yield* applyEnv(
-        import_effect.FiberRef.get(Logix.Debug.internal.currentDebugSinks)
+        import_effect.Effect.service(Logix.Debug.internal.currentDebugSinks).pipe(import_effect.Effect.orDie)
       );
       return { context, loggers, logLevel, debugSinks };
     });
@@ -180,7 +178,7 @@ var useLayerBinding = (runtime, layer, enabled, onError) => {
           const cause = import_effect.Cause.die(error);
           runtime.runFork(
             onError(cause, { source: "provider", phase: "provider.layer.build" }).pipe(
-              import_effect.Effect.catchAllCause(() => import_effect.Effect.void)
+              import_effect.Effect.catchCause(() => import_effect.Effect.void)
             )
           );
         }
@@ -218,18 +216,11 @@ var createRuntimeAdapter = (runtime, contexts, scopes, loggerSets, logLevels, de
   if (contexts.length === 0 && scopes.length === 0 && loggerSets.length === 0 && logLevels.length === 0 && debugSinks.length === 0) {
     return runtime;
   }
-  const applyContexts = (effect) => (
-    // First inherit Provider scopes via scope.extend (preserving FiberRef/Logger changes),
-    // then merge Context via mapInputContext (inner overrides outer).
-    contexts.reduceRight(
-      (acc, ctx) => import_effect.Effect.mapInputContext(
-        acc,
-        (parent) => import_effect.Context.merge(parent, ctx)
-      ),
-      scopes.reduceRight(
-        (acc, scope) => import_effect.Scope.extend(acc, scope),
-        effect
-      )
+  const applyContexts = (effect) => contexts.reduceRight(
+    (acc, ctx) => import_effect.Effect.provideServices(acc, ctx),
+    scopes.reduceRight(
+      (acc, scope) => import_effect.Scope.provide(scope)(acc),
+      effect
     )
   );
   const applyLoggers = (effect) => {
@@ -238,16 +229,13 @@ var createRuntimeAdapter = (runtime, contexts, scopes, loggerSets, logLevels, de
     const sinks = debugSinks.length > 0 ? debugSinks[debugSinks.length - 1] : null;
     let result = effect;
     if (last) {
-      result = import_effect.Effect.locally(import_effect.FiberRef.currentLoggers, last)(result);
+      result = import_effect.Effect.provideService(result, import_effect.Logger.CurrentLoggers, last);
     }
     if (logLevel) {
-      result = import_effect.Effect.locally(import_effect.FiberRef.currentLogLevel, logLevel)(result);
+      result = import_effect.Effect.provideService(result, import_effect.References.MinimumLogLevel, logLevel);
     }
     if (sinks && sinks.length > 0) {
-      result = import_effect.Effect.locally(
-        Logix.Debug.internal.currentDebugSinks,
-        sinks
-      )(result);
+      result = import_effect.Effect.provideService(result, Logix.Debug.internal.currentDebugSinks, sinks);
     }
     return result;
   };
@@ -426,27 +414,41 @@ var applyHandleExtend = (tag, runtime, base) => {
   return { ...base, ...next };
 };
 
+// src/internal/provider/runtimeDebugBridge.ts
+var import_effect3 = require("effect");
+var Logix2 = __toESM(require("@logixjs/core"), 1);
+var readRuntimeDiagnosticsLevel = (runtime) => {
+  try {
+    return runtime.runSync(import_effect3.Effect.service(Logix2.Debug.internal.currentDiagnosticsLevel).pipe(import_effect3.Effect.orDie));
+  } catch {
+    return (0, import_Env.isDevEnv)() ? "light" : "off";
+  }
+};
+var emitRuntimeDebugEventBestEffort = (runtime, event) => {
+  runtime.runFork(event);
+};
+
 // src/internal/store/ModuleCache.ts
-var Logix3 = __toESM(require("@logixjs/core"), 1);
-var import_effect4 = require("effect");
+var Logix4 = __toESM(require("@logixjs/core"), 1);
+var import_effect5 = require("effect");
 
 // src/internal/store/perfWorkloads.ts
-var Logix2 = __toESM(require("@logixjs/core"), 1);
-var import_effect3 = require("effect");
-var PerfCounterStateSchema = import_effect3.Schema.Struct({
-  value: import_effect3.Schema.Number
+var Logix3 = __toESM(require("@logixjs/core"), 1);
+var import_effect4 = require("effect");
+var PerfCounterStateSchema = import_effect4.Schema.Struct({
+  value: import_effect4.Schema.Number
 });
 var PerfCounterActions = {
-  inc: import_effect3.Schema.Void
+  inc: import_effect4.Schema.Void
 };
-var PerfListScopeRowSchema = import_effect3.Schema.Struct({
-  id: import_effect3.Schema.String,
-  warehouseId: import_effect3.Schema.String
+var PerfListScopeRowSchema = import_effect4.Schema.Struct({
+  id: import_effect4.Schema.String,
+  warehouseId: import_effect4.Schema.String
 });
-var PerfListScopeStateSchema = import_effect3.Schema.Struct({
-  items: import_effect3.Schema.Array(PerfListScopeRowSchema),
-  digest: import_effect3.Schema.String,
-  errors: import_effect3.Schema.Any
+var PerfListScopeStateSchema = import_effect4.Schema.Struct({
+  items: import_effect4.Schema.Array(PerfListScopeRowSchema),
+  digest: import_effect4.Schema.String,
+  errors: import_effect4.Schema.Any
 });
 var GLOBAL_YIELD_BUDGET_MEMORY_KEY = "__LOGIX_REACT_YIELD_BUDGET_MEMORY__";
 var getGlobalYieldBudgetMemory = () => {
@@ -541,20 +543,20 @@ ${message}`;
   console.debug(label, message);
 };
 var causeToUnknown = (cause) => {
-  const failure = import_effect4.Option.getOrUndefined(import_effect4.Cause.failureOption(cause));
+  const failure = import_effect5.Option.getOrUndefined(import_effect5.Cause.findErrorOption(cause));
   if (failure !== void 0) return failure;
-  const defect = import_effect4.Option.getOrUndefined(import_effect4.Cause.dieOption(cause));
+  const defect = cause.reasons.filter(import_effect5.Cause.isDieReason).map((reason) => reason.defect)[0];
   if (defect !== void 0) return defect;
   return cause;
 };
 var yieldEffect = (strategy) => {
   switch (strategy) {
     case "none":
-      return import_effect4.Effect.void;
+      return import_effect5.Effect.void;
     case "microtask":
-      return import_effect4.Effect.yieldNow();
+      return import_effect5.Effect.yieldNow;
     case "macrotask":
-      return import_effect4.Effect.promise(
+      return import_effect5.Effect.promise(
         () => new Promise((resolve) => {
           setTimeout(resolve, 0);
         })
@@ -602,11 +604,11 @@ var ModuleCache = class {
         this.scheduleGC(key, current);
         return;
       }
-      void this.runtime.runPromise(import_effect4.Scope.close(current.scope, import_effect4.Exit.void)).catch((error) => {
+      void this.runtime.runPromise(import_effect5.Scope.close(current.scope, import_effect5.Exit.void)).catch((error) => {
         debugBestEffortFailure("[ModuleCache] Scope.close failed", error);
       });
       void this.runtime.runPromise(
-        Logix3.Debug.record({
+        Logix4.Debug.record({
           type: "trace:react.module-instance",
           moduleId: current.ownerId,
           instanceId: current.value?.instanceId,
@@ -642,9 +644,70 @@ var ModuleCache = class {
       }
       return existing.value;
     }
-    const scope = import_effect4.Effect.runSync(import_effect4.Scope.make());
+    const scope = import_effect5.Effect.runSync(import_effect5.Scope.make());
     const workloadKey = `${options?.entrypoint ?? "unknown"}::${ownerId ?? "unknown"}`;
     const yieldDecision = decideYieldStrategy(this.runtime, workloadKey, options?.yield);
+    const optimisticSyncBudgetMs = options?.optimisticSyncBudgetMs ?? 0;
+    const shouldTryOptimisticSync = options?.policyMode === "suspend" && optimisticSyncBudgetMs > 0;
+    if (shouldTryOptimisticSync) {
+      const startedAt2 = performance.now();
+      try {
+        const value = this.runtime.runSync(factory(scope));
+        const durationMs = performance.now() - startedAt2;
+        YieldBudgetMemory.record({ runtime: this.runtime, workloadKey, durationMs });
+        const entry2 = {
+          scope,
+          status: "success",
+          promise: Promise.resolve(value),
+          value,
+          refCount: 0,
+          preloadRefCount: 0,
+          gcTime: gcTime ?? this.gcDelayMs,
+          ownerId,
+          createdBy: "read",
+          workloadKey,
+          yieldStrategy: "none"
+        };
+        this.scheduleGC(key, entry2);
+        this.entries.set(key, entry2);
+        if ((0, import_Env.isDevEnv)() || Logix4.Debug.isDevtoolsEnabled()) {
+          void this.runtime.runPromise(
+            Logix4.Debug.record({
+              type: "trace:react.module.init",
+              moduleId: ownerId,
+              instanceId: value.instanceId,
+              data: {
+                mode: "suspend",
+                key,
+                durationMs: Math.round(durationMs * 100) / 100,
+                yieldStrategy: "none",
+                fastPath: "sync"
+              }
+            })
+          ).catch((error) => {
+            debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
+          });
+          void this.runtime.runPromise(
+            Logix4.Debug.record({
+              type: "trace:react.module-instance",
+              moduleId: ownerId,
+              instanceId: value.instanceId,
+              data: {
+                event: "attach",
+                key,
+                mode: "suspend",
+                gcTime: entry2.gcTime,
+                fastPath: "sync"
+              }
+            })
+          ).catch((error) => {
+            debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
+          });
+        }
+        return value;
+      } catch {
+      }
+    }
     const entry = {
       scope,
       status: "pending",
@@ -660,11 +723,11 @@ var ModuleCache = class {
     };
     this.scheduleGC(key, entry);
     const startedAt = performance.now();
-    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(import_effect4.Effect.zipRight(factory(scope)));
+    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(import_effect5.Effect.flatMap(() => factory(scope)));
     const fiber = this.runtime.runFork(buildEffect);
     entry.fiber = fiber;
-    const promise = this.runtime.runPromise(import_effect4.Fiber.await(fiber)).then((exit) => {
-      if (import_effect4.Exit.isSuccess(exit)) return exit.value;
+    const promise = this.runtime.runPromise(import_effect5.Fiber.await(fiber)).then((exit) => {
+      if (import_effect5.Exit.isSuccess(exit)) return exit.value;
       throw causeToUnknown(exit.cause);
     });
     promise.then((value) => {
@@ -672,9 +735,9 @@ var ModuleCache = class {
       entry.value = value;
       const durationMs = performance.now() - startedAt;
       YieldBudgetMemory.record({ runtime: this.runtime, workloadKey, durationMs });
-      if ((0, import_Env.isDevEnv)() || Logix3.Debug.isDevtoolsEnabled()) {
+      if ((0, import_Env.isDevEnv)() || Logix4.Debug.isDevtoolsEnabled()) {
         void this.runtime.runPromise(
-          Logix3.Debug.record({
+          Logix4.Debug.record({
             type: "trace:react.module.init",
             moduleId: ownerId,
             instanceId: value.instanceId,
@@ -691,7 +754,7 @@ var ModuleCache = class {
           debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
         });
         void this.runtime.runPromise(
-          Logix3.Debug.record({
+          Logix4.Debug.record({
             type: "trace:react.module-instance",
             moduleId: ownerId,
             instanceId: value.instanceId,
@@ -721,7 +784,7 @@ var ModuleCache = class {
         workloadKey,
         durationMs: performance.now() - startedAt
       });
-      void this.runtime.runPromise(import_effect4.Scope.close(scope, import_effect4.Exit.fail(error))).catch((closeError) => {
+      void this.runtime.runPromise(import_effect5.Scope.close(scope, import_effect5.Exit.fail(error))).catch((closeError) => {
         debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
       });
       throw error;
@@ -753,7 +816,7 @@ var ModuleCache = class {
       }
       return existing.value;
     }
-    const scope = this.runtime.runSync(import_effect4.Scope.make());
+    const scope = this.runtime.runSync(import_effect5.Scope.make());
     const startedAt = performance.now();
     try {
       const value = this.runtime.runSync(factory(scope));
@@ -801,9 +864,9 @@ var ModuleCache = class {
           }
         }
       }
-      if ((0, import_Env.isDevEnv)() || Logix3.Debug.isDevtoolsEnabled()) {
+      if ((0, import_Env.isDevEnv)() || Logix4.Debug.isDevtoolsEnabled()) {
         void this.runtime.runPromise(
-          Logix3.Debug.record({
+          Logix4.Debug.record({
             type: "trace:react.module.init",
             moduleId: ownerId,
             instanceId: value.instanceId,
@@ -818,7 +881,7 @@ var ModuleCache = class {
           debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
         });
         void this.runtime.runPromise(
-          Logix3.Debug.record({
+          Logix4.Debug.record({
             type: "trace:react.module-instance",
             moduleId: ownerId,
             instanceId: value.instanceId,
@@ -835,7 +898,7 @@ var ModuleCache = class {
       }
       return value;
     } catch (error) {
-      void this.runtime.runPromise(import_effect4.Scope.close(scope, import_effect4.Exit.fail(error))).catch((closeError) => {
+      void this.runtime.runPromise(import_effect5.Scope.close(scope, import_effect5.Exit.fail(error))).catch((closeError) => {
         debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
       });
       const entry = {
@@ -856,6 +919,49 @@ var ModuleCache = class {
       throw error;
     }
   }
+  warmSync(key, factory, gcTime, ownerId, options) {
+    const existing = this.entries.get(key);
+    if (existing) {
+      if ((0, import_Env.isDevEnv)() && existing.ownerId !== void 0 && ownerId !== void 0 && existing.ownerId !== ownerId) {
+        throw new Error(
+          `[ModuleCache.warmSync] resource key "${key}" has already been claimed by module "${existing.ownerId}", but is now requested by module "${ownerId}".`
+        );
+      }
+      if (existing.status === "success") {
+        return existing.value;
+      }
+      return void 0;
+    }
+    const scope = this.runtime.runSync(import_effect5.Scope.make());
+    const startedAt = performance.now();
+    const workloadKey = `${options?.entrypoint ?? "unknown"}::${ownerId ?? "unknown"}`;
+    try {
+      const value = this.runtime.runSync(factory(scope));
+      const durationMs = performance.now() - startedAt;
+      YieldBudgetMemory.record({ runtime: this.runtime, workloadKey, durationMs });
+      const entry = {
+        scope,
+        status: "success",
+        promise: Promise.resolve(value),
+        value,
+        refCount: 0,
+        preloadRefCount: 0,
+        gcTime: gcTime ?? this.gcDelayMs,
+        ownerId,
+        createdBy: "preload",
+        workloadKey,
+        yieldStrategy: "none"
+      };
+      this.scheduleGC(key, entry);
+      this.entries.set(key, entry);
+      return value;
+    } catch (error) {
+      void this.runtime.runPromise(import_effect5.Scope.close(scope, import_effect5.Exit.fail(error))).catch((closeError) => {
+        debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
+      });
+      return void 0;
+    }
+  }
   preload(key, factory, options) {
     const existing = this.entries.get(key);
     if (existing) {
@@ -880,11 +986,43 @@ var ModuleCache = class {
         }
       };
     }
-    const scope = import_effect4.Effect.runSync(import_effect4.Scope.make());
+    const scope = import_effect5.Effect.runSync(import_effect5.Scope.make());
     const ownerId = options?.ownerId;
     const gcTime = options?.gcTime ?? this.gcDelayMs;
     const workloadKey = `${options?.entrypoint ?? "unknown"}::${ownerId ?? "unknown"}`;
     const yieldDecision = decideYieldStrategy(this.runtime, workloadKey, options?.yield);
+    const optimisticSyncBudgetMs = options?.optimisticSyncBudgetMs ?? 0;
+    const shouldTryOptimisticSync = options?.policyMode === "defer" && optimisticSyncBudgetMs > 0;
+    if (shouldTryOptimisticSync) {
+      const startedAt2 = performance.now();
+      try {
+        const value = this.runtime.runSync(factory(scope));
+        const durationMs = performance.now() - startedAt2;
+        YieldBudgetMemory.record({ runtime: this.runtime, workloadKey, durationMs });
+        const entry2 = {
+          scope,
+          status: "success",
+          promise: Promise.resolve(value),
+          value,
+          refCount: 0,
+          preloadRefCount: 1,
+          gcTime,
+          ownerId,
+          createdBy: "preload",
+          workloadKey,
+          yieldStrategy: "none"
+        };
+        this.scheduleGC(key, entry2);
+        this.entries.set(key, entry2);
+        return {
+          promise: Promise.resolve(value),
+          cancel: () => {
+            this.cancelPreload(key, entry2);
+          }
+        };
+      } catch {
+      }
+    }
     const entry = {
       scope,
       status: "pending",
@@ -900,11 +1038,11 @@ var ModuleCache = class {
     this.scheduleGC(key, entry);
     this.entries.set(key, entry);
     const startedAt = performance.now();
-    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(import_effect4.Effect.zipRight(factory(scope)));
+    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(import_effect5.Effect.flatMap(() => factory(scope)));
     const fiber = this.runtime.runFork(buildEffect);
     entry.fiber = fiber;
-    const promise = this.runtime.runPromise(import_effect4.Fiber.await(fiber)).then((exit) => {
-      if (import_effect4.Exit.isSuccess(exit)) return exit.value;
+    const promise = this.runtime.runPromise(import_effect5.Fiber.await(fiber)).then((exit) => {
+      if (import_effect5.Exit.isSuccess(exit)) return exit.value;
       throw causeToUnknown(exit.cause);
     });
     entry.promise = promise;
@@ -930,7 +1068,7 @@ var ModuleCache = class {
         workloadKey,
         durationMs: performance.now() - startedAt
       });
-      void this.runtime.runPromise(import_effect4.Scope.close(scope, import_effect4.Exit.fail(error))).catch((closeError) => {
+      void this.runtime.runPromise(import_effect5.Scope.close(scope, import_effect5.Exit.fail(error))).catch((closeError) => {
         debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
       });
     });
@@ -962,9 +1100,9 @@ var ModuleCache = class {
       entry.fiber = void 0;
       this.entries.delete(key);
       if (running) {
-        this.runtime.runFork(import_effect4.Fiber.interrupt(running));
+        this.runtime.runFork(import_effect5.Fiber.interrupt(running));
       }
-      void this.runtime.runPromise(import_effect4.Scope.close(entry.scope, import_effect4.Exit.void)).catch((closeError) => {
+      void this.runtime.runPromise(import_effect5.Scope.close(entry.scope, import_effect5.Exit.void)).catch((closeError) => {
         debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
       });
       return;
@@ -1010,7 +1148,7 @@ var ModuleCache = class {
       if (entry.gcTimeout) {
         clearTimeout(entry.gcTimeout);
       }
-      void this.runtime.runPromise(import_effect4.Scope.close(entry.scope, import_effect4.Exit.void)).catch((error) => {
+      void this.runtime.runPromise(import_effect5.Scope.close(entry.scope, import_effect5.Exit.void)).catch((error) => {
         debugBestEffortFailure("[ModuleCache] Scope.close failed", error);
       });
       this.entries.delete(key);
@@ -1066,6 +1204,7 @@ var isModuleRuntime = (value) => typeof value === "object" && value !== null &&
 function useModuleRuntime(handle) {
   const runtime = useRuntime();
   const runtimeContext = (0, import_react4.useContext)(RuntimeContext);
+  const moduleTagResolveTraceRef = (0, import_react4.useRef)(void 0);
   if (!runtimeContext) {
     throw new RuntimeProviderNotFoundError("useModuleRuntime");
   }
@@ -1086,36 +1225,48 @@ 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(import_effect5.Scope.extend(scope));
-    return mode === "suspend" ? cache.read(key, factory, void 0, tokenId, {
+    const startedAtMs = performance.now();
+    const factory = (scope) => import_effect6.Scope.provide(scope)(import_effect6.Effect.service(tag).pipe(import_effect6.Effect.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]);
   (0, import_react4.useEffect)(() => {
     if (!isTagHandle) {
       return;
     }
-    if (!(0, import_Env.isDevEnv)() && !Logix4.Debug.isDevtoolsEnabled()) {
+    const diagnosticsLevel = readRuntimeDiagnosticsLevel(runtime);
+    if (diagnosticsLevel === "off") {
       return;
     }
     const tokenId = handle?.id ?? "ModuleTag";
-    const effect = Logix4.Debug.record({
+    const trace = moduleTagResolveTraceRef.current;
+    const effect = Logix5.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;
 }
@@ -1123,11 +1274,11 @@ function useModuleRuntime(handle) {
 // src/internal/hooks/useSelector.ts
 var import_react5 = require("react");
 var import_with_selector = require("use-sync-external-store/shim/with-selector");
-var Logix6 = __toESM(require("@logixjs/core"), 1);
+var Logix7 = __toESM(require("@logixjs/core"), 1);
 
 // src/internal/store/RuntimeExternalStore.ts
-var Logix5 = __toESM(require("@logixjs/core"), 1);
-var import_effect6 = require("effect");
+var Logix6 = __toESM(require("@logixjs/core"), 1);
+var import_effect7 = require("effect");
 var storesByRuntime = /* @__PURE__ */ new WeakMap();
 var getStoreMapForRuntime = (runtime) => {
   const cached = storesByRuntime.get(runtime);
@@ -1138,8 +1289,8 @@ var getStoreMapForRuntime = (runtime) => {
 };
 var makeModuleInstanceKey = (moduleId, instanceId) => `${moduleId}::${instanceId}`;
 var makeReadQueryTopicKey = (moduleInstanceKey, selectorId) => `${moduleInstanceKey}::rq:${selectorId}`;
-var getRuntimeStore = (runtime) => Logix5.InternalContracts.getRuntimeStore(runtime);
-var getHostScheduler = (runtime) => Logix5.InternalContracts.getHostScheduler(runtime);
+var getRuntimeStore = (runtime) => Logix6.InternalContracts.getRuntimeStore(runtime);
+var getHostScheduler = (runtime) => Logix6.InternalContracts.getHostScheduler(runtime);
 var getOrCreateStore = (runtime, topicKey, make) => {
   const map = getStoreMapForRuntime(runtime);
   const cached = map.get(topicKey);
@@ -1163,6 +1314,8 @@ var makeTopicExternalStore = (args) => {
   let currentSnapshot;
   const listeners = /* @__PURE__ */ new Set();
   let unsubscribeFromRuntimeStore;
+  let teardownScheduled = false;
+  let teardownToken = 0;
   const lowPriorityDelayMs = args.options?.lowPriorityDelayMs ?? 16;
   const lowPriorityMaxDelayMs = args.options?.lowPriorityMaxDelayMs ?? 50;
   let notifyScheduled = false;
@@ -1247,7 +1400,38 @@ var makeTopicExternalStore = (args) => {
     currentSnapshot = next;
     return next;
   };
+  const cancelScheduledTeardown = () => {
+    if (!teardownScheduled) return;
+    teardownScheduled = false;
+    teardownToken += 1;
+  };
+  const finalizeTeardown = () => {
+    if (listeners.size > 0) return;
+    try {
+      args.onLastListener?.();
+    } catch {
+    }
+    const unsub = unsubscribeFromRuntimeStore;
+    unsubscribeFromRuntimeStore = void 0;
+    cancelLow();
+    try {
+      unsub?.();
+    } catch {
+    }
+    removeStore(runtime, topicKey);
+  };
+  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();
@@ -1261,18 +1445,7 @@ var makeTopicExternalStore = (args) => {
     return () => {
       listeners.delete(listener);
       if (listeners.size > 0) return;
-      try {
-        args.onLastListener?.();
-      } catch {
-      }
-      const unsub = unsubscribeFromRuntimeStore;
-      unsubscribeFromRuntimeStore = void 0;
-      cancelLow();
-      try {
-        unsub?.();
-      } catch {
-      }
-      removeStore(runtime, topicKey);
+      scheduleTeardown();
     };
   };
   return { getSnapshot, getServerSnapshot: getSnapshot, subscribe };
@@ -1316,14 +1489,14 @@ var getRuntimeReadQueryExternalStore = (runtime, moduleRuntime, selectorReadQuer
       options,
       onFirstListener: () => {
         if (readQueryDrainFiber) return;
-        const effect = import_effect6.Stream.runDrain(moduleRuntime.changesReadQueryWithMeta(selectorReadQuery));
+        const effect = import_effect7.Stream.runDrain(moduleRuntime.changesReadQueryWithMeta(selectorReadQuery));
         readQueryDrainFiber = runtime.runFork(effect);
       },
       onLastListener: () => {
         const fiber = readQueryDrainFiber;
         if (!fiber) return;
         readQueryDrainFiber = void 0;
-        runtime.runFork(import_effect6.Fiber.interrupt(fiber));
+        runtime.runFork(import_effect7.Fiber.interrupt(fiber));
       }
     })
   );
@@ -1389,7 +1562,7 @@ function useSelector(handle, selector, equalityFn) {
   const moduleRuntime = useModuleRuntime(handle);
   const actualSelector = selector ?? ((state) => state);
   const selectorReadQuery = (0, import_react5.useMemo)(
-    () => typeof selector === "function" ? Logix6.ReadQuery.compile(selector) : void 0,
+    () => typeof selector === "function" ? Logix7.ReadQuery.compile(selector) : void 0,
     [selector]
   );
   const actualEqualityFn = (0, import_react5.useMemo)(() => {
@@ -1427,7 +1600,7 @@ function useSelector(handle, selector, equalityFn) {
     actualEqualityFn
   );
   (0, import_react5.useEffect)(() => {
-    if (!(0, import_Env.isDevEnv)() && !Logix6.Debug.isDevtoolsEnabled()) {
+    if (!(0, import_Env.isDevEnv)() && !Logix7.Debug.isDevtoolsEnabled()) {
       return;
     }
     const instanceId = moduleRuntime.instanceId;
@@ -1443,7 +1616,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 = Logix6.Debug.record({
+    const effect = Logix7.Debug.record({
       type: "trace:react-selector",
       moduleId: moduleRuntime.moduleId,
       instanceId,
@@ -1466,7 +1639,7 @@ function useSelector(handle, selector, equalityFn) {
 }
 
 // src/internal/store/resolveImportedModuleRef.ts
-var Logix7 = __toESM(require("@logixjs/core"), 1);
+var Logix8 = __toESM(require("@logixjs/core"), 1);
 var getOrCreateWeakMap = (map, key, make) => {
   const cached = map.get(key);
   if (cached) return cached;
@@ -1490,7 +1663,7 @@ var resolveImportedModuleRef = (runtime, parentRuntime, module2) => {
   if (cached) {
     return cached;
   }
-  const importsScope = Logix7.InternalContracts.getImportsScope(parentRuntime);
+  const importsScope = Logix8.InternalContracts.getImportsScope(parentRuntime);
   const childRuntime = importsScope.get(module2);
   if (childRuntime) {
     const dispatch = Object.assign(
@@ -1576,8 +1749,8 @@ var useStableId = () => {
 
 // src/internal/hooks/useModule.ts
 var isModuleImpl = (handle) => Boolean(handle) && typeof handle === "object" && handle._tag === "ModuleImpl";
-var isModule = (handle) => Logix8.Module.hasImpl(handle);
-var isModuleDef = (handle) => Logix8.Module.is(handle) && handle._kind === "ModuleDef";
+var isModule = (handle) => Logix9.Module.hasImpl(handle);
+var isModuleDef = (handle) => Logix9.Module.is(handle) && handle._kind === "ModuleDef";
 function useModule(handle, selectorOrOptions, equalityFn) {
   const runtimeBase = useRuntime();
   const runtimeContext = import_react7.default.useContext(RuntimeContext);
@@ -1601,6 +1774,7 @@ function useModule(handle, selectorOrOptions, equalityFn) {
     }
   }
   let runtime;
+  const moduleImplResolveTraceRef = import_react7.default.useRef(void 0);
   if (isModuleImpl(normalizedHandle)) {
     const cache = import_react7.default.useMemo(
       () => getModuleCache(runtimeBase, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion),
@@ -1629,9 +1803,9 @@ function useModule(handle, selectorOrOptions, equalityFn) {
     const key = depsHash ? `${baseKey}:${depsHash}` : baseKey;
     const ownerId = moduleId;
     const baseFactory = import_react7.default.useMemo(
-      () => (scope) => import_effect7.Layer.buildWithScope(normalizedHandle.layer, scope).pipe(
-        import_effect7.Effect.map(
-          (context) => import_effect7.Context.get(context, normalizedHandle.module)
+      () => (scope) => import_effect8.Layer.buildWithScope(import_effect8.Layer.fresh(normalizedHandle.layer), scope).pipe(
+        import_effect8.Effect.map(
+          (context) => import_effect8.ServiceMap.get(context, normalizedHandle.module)
         )
       ),
       [normalizedHandle]
@@ -1641,26 +1815,56 @@ function useModule(handle, selectorOrOptions, equalityFn) {
         return baseFactory;
       }
       return (scope) => baseFactory(scope).pipe(
-        import_effect7.Effect.timeoutFail({
-          duration: initTimeoutMs,
-          onTimeout: () => new Error(`[useModule] Module "${ownerId}" initialization timed out after ${initTimeoutMs}ms`)
-        })
+        import_effect8.Effect.timeoutOption(initTimeoutMs),
+        import_effect8.Effect.flatMap(
+          (maybe) => maybe._tag === "Some" ? import_effect8.Effect.succeed(maybe.value) : import_effect8.Effect.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
+    };
     import_react7.default.useEffect(() => cache.retain(key), [cache, key]);
     runtime = moduleRuntime;
   } else {
     runtime = useModuleRuntime(normalizedHandle);
   }
+  import_react7.default.useEffect(() => {
+    if (!isModuleImpl(normalizedHandle)) {
+      return;
+    }
+    const diagnosticsLevel = readRuntimeDiagnosticsLevel(runtimeBase);
+    if (diagnosticsLevel === "off") {
+      return;
+    }
+    const trace = moduleImplResolveTraceRef.current;
+    if (!trace) {
+      return;
+    }
+    const effect = Logix9.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]);
   import_react7.default.useEffect(() => {
     if (!isModuleImpl(normalizedHandle)) {
       return;
@@ -1670,22 +1874,22 @@ function useModule(handle, selectorOrOptions, equalityFn) {
     if (!label) {
       return;
     }
-    const effect = Logix8.Debug.record({
+    const effect = Logix9.Debug.record({
       type: "trace:instanceLabel",
       moduleId: normalizedHandle.module.id,
       instanceId: runtime.instanceId,
       data: { label }
     });
-    runtimeBase.runFork(effect);
+    emitRuntimeDebugEventBestEffort(runtimeBase, effect);
   }, [runtimeBase, runtime, normalizedHandle, options]);
   import_react7.default.useEffect(() => {
-    if (!(0, import_Env.isDevEnv)() && !Logix8.Debug.isDevtoolsEnabled()) {
+    if (!(0, import_Env.isDevEnv)() && !Logix9.Debug.isDevtoolsEnabled()) {
       return;
     }
     if (!runtime.instanceId) {
       return;
     }
-    const effect = Logix8.Debug.record({
+    const effect = Logix9.Debug.record({
       type: "trace:react-render",
       moduleId: runtime.moduleId,
       instanceId: runtime.instanceId,
@@ -1695,7 +1899,7 @@ function useModule(handle, selectorOrOptions, equalityFn) {
       }
     });
     runtimeBase.runFork(effect);
-  }, [runtimeBase, runtime]);
+  });
   if (selector) {
     if (isModuleImpl(normalizedHandle)) {
       return useSelector(runtime, selector, equalityFn);
@@ -1782,12 +1986,12 @@ function useModule(handle, selectorOrOptions, equalityFn) {
 
 // src/internal/provider/RuntimeProvider.tsx
 var import_react9 = __toESM(require("react"), 1);
-var import_effect9 = require("effect");
-var Logix10 = __toESM(require("@logixjs/core"), 1);
+var import_effect10 = require("effect");
+var Logix11 = __toESM(require("@logixjs/core"), 1);
 
 // src/internal/provider/config.ts
-var import_effect8 = require("effect");
-var ReactRuntimeConfigTag = class extends import_effect8.Context.Tag("@logixjs/react/RuntimeConfig")() {
+var import_effect9 = require("effect");
+var ReactRuntimeConfigTag = class extends import_effect9.ServiceMap.Service()("@logixjs/react/RuntimeConfig") {
 };
 var DEFAULT_CONFIG = {
   gcTime: 500,
@@ -1808,58 +2012,58 @@ var ReactModuleConfigFromEnv = {
    * - Applies when not explicitly specified in useModule(options.gcTime).
    * - Default: 500ms (StrictMode jitter protection).
    */
-  gcTime: import_effect8.Config.number("logix.react.gc_time").pipe(import_effect8.Config.withDefault(DEFAULT_CONFIG.gcTime)),
+  gcTime: import_effect9.Config.number("logix.react.gc_time").pipe(import_effect9.Config.withDefault(DEFAULT_CONFIG.gcTime)),
   /**
    * Default init timeout (ms), only effective when suspend:true.
    * - Uses Option<number> to represent "optional config": missing means init timeout is disabled.
    * - Callers can map Option.none to undefined.
    */
-  initTimeoutMs: import_effect8.Config.option(import_effect8.Config.number("logix.react.init_timeout_ms")),
+  initTimeoutMs: import_effect9.Config.option(import_effect9.Config.number("logix.react.init_timeout_ms")),
   /**
    * Delay (ms) for low-priority notification scheduling.
    * - Roughly "defer to the next frame" cadence (default 16ms).
    */
-  lowPriorityDelayMs: import_effect8.Config.number("logix.react.low_priority_delay_ms").pipe(
-    import_effect8.Config.withDefault(DEFAULT_CONFIG.lowPriorityDelayMs ?? 16)
+  lowPriorityDelayMs: import_effect9.Config.number("logix.react.low_priority_delay_ms").pipe(
+    import_effect9.Config.withDefault(DEFAULT_CONFIG.lowPriorityDelayMs ?? 16)
   ),
   /**
    * Maximum delay upper bound (ms) for low-priority notification scheduling.
    * - Ensures eventual delivery, avoiding indefinite coalescing under extreme high-frequency scenarios.
    * - Default 50ms.
    */
-  lowPriorityMaxDelayMs: import_effect8.Config.number("logix.react.low_priority_max_delay_ms").pipe(
-    import_effect8.Config.withDefault(DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50)
+  lowPriorityMaxDelayMs: import_effect9.Config.number("logix.react.low_priority_max_delay_ms").pipe(
+    import_effect9.Config.withDefault(DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50)
   )
 };
 var ReactModuleConfig = {
-  gcTime: import_effect8.Effect.gen(function* () {
-    const override = yield* import_effect8.Effect.serviceOption(ReactRuntimeConfigTag);
-    if (import_effect8.Option.isSome(override)) {
+  gcTime: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
       return override.value.gcTime;
     }
     const value = yield* ReactModuleConfigFromEnv.gcTime;
     return value;
   }),
-  initTimeoutMs: import_effect8.Effect.gen(function* () {
-    const override = yield* import_effect8.Effect.serviceOption(ReactRuntimeConfigTag);
-    if (import_effect8.Option.isSome(override)) {
+  initTimeoutMs: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
       const v = override.value.initTimeoutMs;
-      return v === void 0 ? import_effect8.Option.none() : import_effect8.Option.some(v);
+      return v === void 0 ? import_effect9.Option.none() : import_effect9.Option.some(v);
     }
     const opt = yield* ReactModuleConfigFromEnv.initTimeoutMs;
     return opt;
   }),
-  lowPriorityDelayMs: import_effect8.Effect.gen(function* () {
-    const override = yield* import_effect8.Effect.serviceOption(ReactRuntimeConfigTag);
-    if (import_effect8.Option.isSome(override)) {
+  lowPriorityDelayMs: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
       return override.value.lowPriorityDelayMs ?? DEFAULT_CONFIG.lowPriorityDelayMs ?? 16;
     }
     const value = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
     return value;
   }),
-  lowPriorityMaxDelayMs: import_effect8.Effect.gen(function* () {
-    const override = yield* import_effect8.Effect.serviceOption(ReactRuntimeConfigTag);
-    if (import_effect8.Option.isSome(override)) {
+  lowPriorityMaxDelayMs: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
       return override.value.lowPriorityMaxDelayMs ?? DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50;
     }
     const value = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
@@ -1867,9 +2071,9 @@ var ReactModuleConfig = {
   })
 };
 var ReactRuntimeConfigSnapshot = {
-  load: import_effect8.Effect.gen(function* () {
-    const runtimeOverride = yield* import_effect8.Effect.serviceOption(ReactRuntimeConfigTag);
-    if (import_effect8.Option.isSome(runtimeOverride)) {
+  load: import_effect9.Effect.gen(function* () {
+    const runtimeOverride = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(runtimeOverride)) {
       return {
         gcTime: runtimeOverride.value.gcTime,
         initTimeoutMs: runtimeOverride.value.initTimeoutMs,
@@ -1880,10 +2084,10 @@ var ReactRuntimeConfigSnapshot = {
     }
     const envGcTime = yield* ReactModuleConfigFromEnv.gcTime;
     const envInitTimeoutOpt = yield* ReactModuleConfigFromEnv.initTimeoutMs;
-    const envInitTimeout = import_effect8.Option.getOrUndefined(envInitTimeoutOpt);
+    const envInitTimeout = import_effect9.Option.getOrUndefined(envInitTimeoutOpt);
     const envLowPriorityDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
     const envLowPriorityMaxDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
-    const fromConfig = envGcTime !== DEFAULT_CONFIG.gcTime || import_effect8.Option.isSome(envInitTimeoutOpt) || envLowPriorityDelayMs !== (DEFAULT_CONFIG.lowPriorityDelayMs ?? 16) || envLowPriorityMaxDelayMs !== (DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50);
+    const fromConfig = envGcTime !== DEFAULT_CONFIG.gcTime || import_effect9.Option.isSome(envInitTimeoutOpt) || envLowPriorityDelayMs !== (DEFAULT_CONFIG.lowPriorityDelayMs ?? 16) || envLowPriorityMaxDelayMs !== (DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50);
     if (fromConfig) {
       return {
         gcTime: envGcTime,
@@ -1899,7 +2103,7 @@ var ReactRuntimeConfigSnapshot = {
 
 // src/internal/provider/fallback.tsx
 var import_react8 = require("react");
-var Logix9 = __toESM(require("@logixjs/core"), 1);
+var Logix10 = __toESM(require("@logixjs/core"), 1);
 
 // src/internal/provider/docs.ts
 var LOGIX_DOCS_PREFIX_ENV = "LOGIX_DOCS_PREFIX";
@@ -2002,11 +2206,11 @@ var resolveRuntimeProviderFallback = (args) => {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultRuntimeFallback, { phase: args.phase, policyMode: args.policyMode });
 };
 var recordFallbackDuration = (args) => {
-  if (!(0, import_Env.isDevEnv)() && !Logix9.Debug.isDevtoolsEnabled()) {
+  if (!(0, import_Env.isDevEnv)() && !Logix10.Debug.isDevtoolsEnabled()) {
     return;
   }
   void args.runtime.runPromise(
-    Logix9.Debug.record({
+    Logix10.Debug.record({
       type: "trace:react.fallback.duration",
       data: {
         phase: args.phase,
@@ -2085,7 +2289,7 @@ var FallbackProbeEnabled = ({ runtime, phase, policyMode, blockers, children })
 };
 var FallbackProbeNoop = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
 var FallbackProbe = (props) => {
-  const enabled = (0, import_Env.isDevEnv)() || Logix9.Debug.isDevtoolsEnabled();
+  const enabled = (0, import_Env.isDevEnv)() || Logix10.Debug.isDevtoolsEnabled();
   const Impl = enabled ? FallbackProbeEnabled : FallbackProbeNoop;
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Impl, { ...props });
 };
@@ -2168,6 +2372,9 @@ var RuntimeProvider = ({
 }) => {
   const parent = (0, import_react9.useContext)(RuntimeContext);
   const baseRuntime = useRuntimeResolution(runtime, parent);
+  const providerStartedAtRef = import_react9.default.useRef(performance.now());
+  const providerReadyAtRef = import_react9.default.useRef(void 0);
+  const didReportProviderGatingRef = import_react9.default.useRef(false);
   const resolvedPolicy = (0, import_react9.useMemo)(
     () => resolveRuntimeProviderPolicy({
       policy,
@@ -2179,7 +2386,7 @@ var RuntimeProvider = ({
   onErrorRef.current = onError;
   const hasTickServices = (0, import_react9.useMemo)(() => {
     try {
-      Logix10.InternalContracts.getRuntimeStore(baseRuntime);
+      Logix11.InternalContracts.getRuntimeStore(baseRuntime);
       return true;
     } catch {
       return false;
@@ -2187,7 +2394,7 @@ var RuntimeProvider = ({
   }, [baseRuntime]);
   const { binding: tickBinding } = useLayerBinding(
     baseRuntime,
-    Logix10.InternalContracts.tickServicesLayer,
+    Logix11.InternalContracts.tickServicesLayer,
     !hasTickServices,
     onErrorRef.current
   );
@@ -2198,7 +2405,7 @@ var RuntimeProvider = ({
       record: (event) => {
         const handler = onErrorRef.current;
         if (!handler) {
-          return import_effect9.Effect.void;
+          return import_effect10.Effect.void;
         }
         if (event.type === "lifecycle:error") {
           return handler(event.cause, {
@@ -2207,11 +2414,11 @@ var RuntimeProvider = ({
             moduleId: event.moduleId,
             instanceId: event.instanceId,
             runtimeLabel: event.runtimeLabel
-          }).pipe(import_effect9.Effect.catchAllCause(() => import_effect9.Effect.void));
+          }).pipe(import_effect10.Effect.catchCause(() => import_effect10.Effect.void));
         }
         if (event.type === "diagnostic" && event.severity === "error") {
           return handler(
-            import_effect9.Cause.fail({
+            import_effect10.Cause.fail({
               code: event.code,
               message: event.message,
               hint: event.hint
@@ -2226,9 +2433,9 @@ var RuntimeProvider = ({
               instanceId: event.instanceId,
               runtimeLabel: event.runtimeLabel
             }
-          ).pipe(import_effect9.Effect.catchAllCause(() => import_effect9.Effect.void));
+          ).pipe(import_effect10.Effect.catchCause(() => import_effect10.Effect.void));
         }
-        return import_effect9.Effect.void;
+        return import_effect10.Effect.void;
       }
     };
     return sink;
@@ -2241,9 +2448,7 @@ var RuntimeProvider = ({
       return layerBinding.debugSinks;
     }
     try {
-      return baseRuntime.runSync(
-        import_effect9.FiberRef.get(Logix10.Debug.internal.currentDebugSinks)
-      );
+      return baseRuntime.runSync(import_effect10.Effect.service(Logix11.Debug.internal.currentDebugSinks).pipe(import_effect10.Effect.orDie));
     } catch {
       return [];
     }
@@ -2301,7 +2506,7 @@ var RuntimeProvider = ({
     }
     didReportSyncConfigSnapshotRef.current = true;
     void runtimeWithBindings.runPromise(
-      Logix10.Debug.record({
+      Logix11.Debug.record({
         type: "trace:react.runtime.config.snapshot",
         data: {
           source: configState.snapshot.source,
@@ -2332,7 +2537,7 @@ var RuntimeProvider = ({
         };
       });
       void runtimeWithBindings.runPromise(
-        Logix10.Debug.record({
+        Logix11.Debug.record({
           type: "trace:react.runtime.config.snapshot",
           data: {
             source: snapshot.source,
@@ -2370,6 +2575,41 @@ var RuntimeProvider = ({
   const resolveFallback = (phase) => {
     return resolveRuntimeProviderFallback({ fallback, phase, policyMode: resolvedPolicy.mode });
   };
+  const preloadCache = (0, import_react9.useMemo)(
+    () => getModuleCache(runtimeWithBindings, configState.snapshot, configState.version),
+    [runtimeWithBindings, configState.snapshot, configState.version]
+  );
+  const syncWarmPreloadReady = (0, import_react9.useMemo)(() => {
+    if (resolvedPolicy.mode !== "defer") return false;
+    if (!resolvedPolicy.preload) return true;
+    if (!isLayerReady || !isConfigReady) return false;
+    const handles = resolvedPolicy.preload.handles;
+    if (handles.length === 0) return true;
+    for (const handle of handles) {
+      if (handle?._tag === "ModuleImpl") {
+        const moduleId = handle.module?.id ?? "ModuleImpl";
+        const key2 = resolvedPolicy.preload.keysByModuleId.get(moduleId) ?? getPreloadKeyForModuleId(moduleId);
+        const factory2 = (scope) => import_effect10.Layer.buildWithScope(handle.layer, scope).pipe(
+          import_effect10.Effect.map((context) => import_effect10.ServiceMap.get(context, handle.module))
+        );
+        const value2 = preloadCache.warmSync(key2, factory2, configState.snapshot.gcTime, moduleId, {
+          entrypoint: "react.runtime.preload.sync-warm",
+          policyMode: "defer"
+        });
+        if (!value2) return false;
+        continue;
+      }
+      const tagId = handle.id ?? "ModuleTag";
+      const key = resolvedPolicy.preload.keysByTagId.get(tagId) ?? getPreloadKeyForTagId(tagId);
+      const factory = (scope) => import_effect10.Scope.provide(scope)(import_effect10.Effect.service(handle).pipe(import_effect10.Effect.orDie));
+      const value = preloadCache.warmSync(key, factory, configState.snapshot.gcTime, tagId, {
+        entrypoint: "react.runtime.preload.sync-warm",
+        policyMode: "defer"
+      });
+      if (!value) return false;
+    }
+    return true;
+  }, [resolvedPolicy, isLayerReady, isConfigReady, preloadCache, configState.snapshot.gcTime]);
   const [deferReady, setDeferReady] = (0, import_react9.useState)(false);
   (0, import_react9.useEffect)(() => {
     if (resolvedPolicy.mode !== "defer") {
@@ -2383,6 +2623,10 @@ var RuntimeProvider = ({
     if (resolvedPolicy.mode !== "defer") {
       return;
     }
+    if (syncWarmPreloadReady) {
+      setDeferReady(true);
+      return;
+    }
     setDeferReady(false);
     if (!resolvedPolicy.preload) {
       setDeferReady(true);
@@ -2392,7 +2636,7 @@ var RuntimeProvider = ({
       return;
     }
     let cancelled = false;
-    const cache = getModuleCache(runtimeWithBindings, configState.snapshot, configState.version);
+    const cache = preloadCache;
     const preloadHandles = resolvedPolicy.preload.handles;
     if (preloadHandles.length === 0) {
       setDeferReady(true);
@@ -2409,20 +2653,21 @@ var RuntimeProvider = ({
         if (handle?._tag === "ModuleImpl") {
           const moduleId = handle.module?.id ?? "ModuleImpl";
           const key2 = resolvedPolicy.preload.keysByModuleId.get(moduleId) ?? getPreloadKeyForModuleId(moduleId);
-          const factory2 = (scope) => import_effect9.Layer.buildWithScope(handle.layer, scope).pipe(
-            import_effect9.Effect.map((context) => import_effect9.Context.get(context, handle.module))
+          const factory2 = (scope) => import_effect10.Layer.buildWithScope(handle.layer, scope).pipe(
+            import_effect10.Effect.map((context) => import_effect10.ServiceMap.get(context, handle.module))
           );
           const op2 = cache.preload(key2, factory2, {
             ownerId: moduleId,
             yield: resolvedPolicy.preload.yield,
             entrypoint: "react.runtime.preload",
-            policyMode: "defer"
+            policyMode: "defer",
+            optimisticSyncBudgetMs: resolvedPolicy.syncBudgetMs
           });
           allCancels.add(op2.cancel);
           await op2.promise;
           const durationMs2 = performance.now() - startedAt;
           void runtimeWithBindings.runPromise(
-            Logix10.Debug.record({
+            Logix11.Debug.record({
               type: "trace:react.module.preload",
               moduleId,
               data: {
@@ -2441,20 +2686,19 @@ var RuntimeProvider = ({
         }
         const tagId = handle.id ?? "ModuleTag";
         const key = resolvedPolicy.preload.keysByTagId.get(tagId) ?? getPreloadKeyForTagId(tagId);
-        const factory = (scope) => handle.pipe(
-          import_effect9.Scope.extend(scope)
-        );
+        const factory = (scope) => import_effect10.Scope.provide(scope)(import_effect10.Effect.service(handle).pipe(import_effect10.Effect.orDie));
         const op = cache.preload(key, factory, {
           ownerId: tagId,
           yield: resolvedPolicy.preload.yield,
           entrypoint: "react.runtime.preload",
-          policyMode: "defer"
+          policyMode: "defer",
+          optimisticSyncBudgetMs: resolvedPolicy.syncBudgetMs
         });
         allCancels.add(op.cancel);
         await op.promise;
         const durationMs = performance.now() - startedAt;
         void runtimeWithBindings.runPromise(
-          Logix10.Debug.record({
+          Logix11.Debug.record({
             type: "trace:react.module.preload",
             data: {
               mode: "defer",
@@ -2486,7 +2730,7 @@ var RuntimeProvider = ({
       if (cancelled) return;
       if (onErrorRef.current) {
         runtimeWithBindings.runFork(
-          onErrorRef.current(import_effect9.Cause.die(error), { source: "provider", phase: "provider.layer.build" }).pipe(import_effect9.Effect.catchAllCause(() => import_effect9.Effect.void))
+          onErrorRef.current(import_effect10.Cause.die(error), { source: "provider", phase: "provider.layer.build" }).pipe(import_effect10.Effect.catchCause(() => import_effect10.Effect.void))
         );
       }
       setDeferReady(true);
@@ -2519,13 +2763,54 @@ var RuntimeProvider = ({
       release();
     };
   }, [resolvedPolicy.mode, deferReady]);
-  const isReady = isTickServicesReady && isLayerReady && isConfigReady && (resolvedPolicy.mode !== "defer" || deferReady);
+  const isReady = isTickServicesReady && isLayerReady && isConfigReady && (resolvedPolicy.mode !== "defer" || deferReady || syncWarmPreloadReady);
+  if (isReady && providerReadyAtRef.current === void 0) {
+    providerReadyAtRef.current = performance.now();
+  }
+  (0, import_react9.useEffect)(() => {
+    if (!isReady) {
+      return;
+    }
+    if (didReportProviderGatingRef.current) {
+      return;
+    }
+    let diagnosticsLevel = "off";
+    try {
+      diagnosticsLevel = runtimeWithBindings.runSync(
+        import_effect10.Effect.service(Logix11.Debug.internal.currentDiagnosticsLevel).pipe(import_effect10.Effect.orDie)
+      );
+    } catch {
+      diagnosticsLevel = (0, import_Env.isDevEnv)() ? "light" : "off";
+    }
+    if (diagnosticsLevel === "off") {
+      return;
+    }
+    didReportProviderGatingRef.current = true;
+    const readyAt = providerReadyAtRef.current ?? performance.now();
+    const durationMs = Math.round((readyAt - providerStartedAtRef.current) * 100) / 100;
+    const effectDelayMs = Math.round((performance.now() - readyAt) * 100) / 100;
+    void runtimeWithBindings.runPromise(
+      Logix11.Debug.record({
+        type: "trace:react.provider.gating",
+        data: {
+          event: "ready",
+          policyMode: resolvedPolicy.mode,
+          durationMs,
+          effectDelayMs,
+          configLoadMode: configState.loadMode,
+          syncOverBudget: Boolean(configState.syncOverBudget),
+          syncDurationMs: configState.syncDurationMs !== void 0 ? Math.round(configState.syncDurationMs * 100) / 100 : void 0
+        }
+      })
+    ).catch(() => {
+    });
+  }, [configState.loadMode, configState.syncDurationMs, configState.syncOverBudget, isReady, resolvedPolicy.mode, runtimeWithBindings]);
   if (!isReady) {
     const blockersList = [
       isTickServicesReady ? null : "tick",
       isLayerReady ? null : "layer",
       isConfigReady ? null : "config",
-      resolvedPolicy.mode !== "defer" || deferReady ? null : "preload"
+      resolvedPolicy.mode !== "defer" || deferReady || syncWarmPreloadReady ? null : "preload"
     ].filter((x) => x !== null);
     const blockers = blockersList.length > 0 ? blockersList.join("+") : void 0;
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
@@ -2560,14 +2845,16 @@ var useRuntimeResolution = (runtimeProp, parent) => {
 
 // src/ModuleScope.ts
 var makeModuleScope = (handle, defaults) => {
-  const Context5 = import_react10.default.createContext(null);
+  const Context = import_react10.default.createContext(null);
   const toUseModuleOptions = (options) => {
     const { scopeId, ...rest } = options;
     return scopeId != null ? { ...rest, key: scopeId } : rest;
   };
   const getRegistryOrThrow = (runtime, where) => {
     try {
-      const registry = runtime.runSync(Logix11.ScopeRegistry.ScopeRegistryTag);
+      const registry = runtime.runSync(
+        import_effect11.Effect.service(Logix12.ScopeRegistry.ScopeRegistryTag).pipe(import_effect11.Effect.orDie)
+      );
       if (!registry) {
         throw new Error("ScopeRegistry service is undefined");
       }
@@ -2578,7 +2865,7 @@ var makeModuleScope = (handle, defaults) => {
       );
     }
   };
-  const moduleToken = Logix11.Module.hasImpl(handle) ? handle.tag : handle.module;
+  const moduleToken = Logix12.Module.hasImpl(handle) ? handle.tag : handle.module;
   const Provider = ({ children, options }) => {
     const runtime = useRuntime();
     const merged = defaults || options ? { ...defaults ?? {}, ...options ?? {} } : void 0;
@@ -2587,17 +2874,17 @@ var makeModuleScope = (handle, defaults) => {
     import_react10.default.useEffect(() => {
       if (!scopeId) return;
       const registry = getRegistryOrThrow(runtime, "[ModuleScope]");
-      const leaseRuntime = registry.register(scopeId, Logix11.ScopeRegistry.ScopedRuntimeTag, runtime);
+      const leaseRuntime = registry.register(scopeId, Logix12.ScopeRegistry.ScopedRuntimeTag, runtime);
       const leaseModule = registry.register(scopeId, moduleToken, ref.runtime);
       return () => {
         leaseModule.release();
         leaseRuntime.release();
       };
     }, [runtime, scopeId, ref.runtime]);
-    return import_react10.default.createElement(Context5.Provider, { value: ref }, children);
+    return import_react10.default.createElement(Context.Provider, { value: ref }, children);
   };
   const use = () => {
-    const ref = import_react10.default.useContext(Context5);
+    const ref = import_react10.default.useContext(Context);
     if (!ref) {
       throw new Error("[ModuleScope] Provider not found");
     }
@@ -2610,7 +2897,7 @@ var makeModuleScope = (handle, defaults) => {
   const Bridge = ({ scopeId, children }) => {
     const runtime = useRuntime();
     const registry = getRegistryOrThrow(runtime, "[ModuleScope.Bridge]");
-    const scopedRuntime = registry.get(scopeId, Logix11.ScopeRegistry.ScopedRuntimeTag);
+    const scopedRuntime = registry.get(scopeId, Logix12.ScopeRegistry.ScopedRuntimeTag);
     const moduleRuntime = registry.get(scopeId, moduleToken);
     if (!scopedRuntime || !moduleRuntime) {
       throw new Error(
@@ -2620,18 +2907,18 @@ var makeModuleScope = (handle, defaults) => {
     return import_react10.default.createElement(
       RuntimeProvider,
       { runtime: scopedRuntime },
-      import_react10.default.createElement(BridgeInner, { moduleRuntime, Context: Context5 }, children)
+      import_react10.default.createElement(BridgeInner, { moduleRuntime, Context }, children)
     );
   };
   const BridgeInner = ({
     moduleRuntime,
-    Context: Context6,
+    Context: Context2,
     children
   }) => {
     const ref = useModule(moduleRuntime);
-    return import_react10.default.createElement(Context6.Provider, { value: ref }, children);
+    return import_react10.default.createElement(Context2.Provider, { value: ref }, children);
   };
-  return { Provider, use, useImported, Context: Context5, Bridge };
+  return { Provider, use, useImported, Context, Bridge };
 };
 var ModuleScope = {
   make: makeModuleScope