@logixjs/react 0.1.0 → 1.0.0

package/dist/{chunk-4G7H66OY.js → chunk-KYWW4KMQ.js}

@@ -1,14 +1,14 @@
 import {
   useDispatch,
   useLocalModule
-} from "./chunk-PYWHL7TA.js";
+} from "./chunk-6NLXTHZ7.js";
 import {
   useModule,
   useSelector
-} from "./chunk-UFFCJGSZ.js";
+} from "./chunk-E3ZXST5F.js";
 import {
   RuntimeProvider
-} from "./chunk-JXAJTWSZ.js";
+} from "./chunk-XSGDBJXD.js";
 
 // src/ReactPlatform.ts
 import React from "react";

package/dist/{chunk-2WFULYPJ.js → chunk-L7KTYBXN.js}

@@ -7,7 +7,7 @@ import { getNodeEnv, isDevEnv } from "@logixjs/core/Env";
 
 // src/internal/provider/runtimeBindings.ts
 import { useEffect, useRef, useState } from "react";
-import { Layer, Exit, Context, Effect, Cause, FiberRef, Scope } from "effect";
+import { Cause, Effect, Exit, Layer, Logger, References, Scope } from "effect";
 import * as Logix from "@logixjs/core";
 var toErrorString = (error) => error instanceof Error ? error.stack ?? error.message : String(error);
 var debugScopeCloseFailure = (error) => {
@@ -76,14 +76,11 @@ var useLayerBinding = (runtime, layer, enabled, onError) => {
     const newScope = Effect.runSync(Scope.make());
     const buildEffect = Effect.gen(function* () {
       const context = yield* Layer.buildWithScope(layer, newScope);
-      const applyEnv = (effect) => Effect.mapInputContext(
-        Scope.extend(effect, newScope),
-        (parent) => Context.merge(parent, context)
-      );
-      const loggers = yield* applyEnv(FiberRef.get(FiberRef.currentLoggers));
-      const logLevel = yield* applyEnv(FiberRef.get(FiberRef.currentLogLevel));
+      const applyEnv = (effect) => Scope.provide(newScope)(Effect.provideServices(effect, context));
+      const loggers = yield* applyEnv(Effect.service(Logger.CurrentLoggers)).pipe(Effect.orDie);
+      const logLevel = yield* applyEnv(Effect.service(References.MinimumLogLevel)).pipe(Effect.orDie);
       const debugSinks = yield* applyEnv(
-        FiberRef.get(Logix.Debug.internal.currentDebugSinks)
+        Effect.service(Logix.Debug.internal.currentDebugSinks).pipe(Effect.orDie)
       );
       return { context, loggers, logLevel, debugSinks };
     });
@@ -128,7 +125,7 @@ var useLayerBinding = (runtime, layer, enabled, onError) => {
           const cause = Cause.die(error);
           runtime.runFork(
             onError(cause, { source: "provider", phase: "provider.layer.build" }).pipe(
-              Effect.catchAllCause(() => Effect.void)
+              Effect.catchCause(() => Effect.void)
             )
           );
         }
@@ -166,18 +163,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) => Effect.mapInputContext(
-        acc,
-        (parent) => Context.merge(parent, ctx)
-      ),
-      scopes.reduceRight(
-        (acc, scope) => Scope.extend(acc, scope),
-        effect
-      )
+  const applyContexts = (effect) => contexts.reduceRight(
+    (acc, ctx) => Effect.provideServices(acc, ctx),
+    scopes.reduceRight(
+      (acc, scope) => Scope.provide(scope)(acc),
+      effect
     )
   );
   const applyLoggers = (effect) => {
@@ -186,16 +176,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 = Effect.locally(FiberRef.currentLoggers, last)(result);
+      result = Effect.provideService(result, Logger.CurrentLoggers, last);
     }
     if (logLevel) {
-      result = Effect.locally(FiberRef.currentLogLevel, logLevel)(result);
+      result = Effect.provideService(result, References.MinimumLogLevel, logLevel);
     }
     if (sinks && sinks.length > 0) {
-      result = Effect.locally(
-        Logix.Debug.internal.currentDebugSinks,
-        sinks
-      )(result);
+      result = Effect.provideService(result, Logix.Debug.internal.currentDebugSinks, sinks);
     }
     return result;
   };
@@ -326,9 +313,9 @@ ${message}`;
   console.debug(label, message);
 };
 var causeToUnknown = (cause) => {
-  const failure = Option.getOrUndefined(Cause2.failureOption(cause));
+  const failure = Option.getOrUndefined(Cause2.findErrorOption(cause));
   if (failure !== void 0) return failure;
-  const defect = Option.getOrUndefined(Cause2.dieOption(cause));
+  const defect = cause.reasons.filter(Cause2.isDieReason).map((reason) => reason.defect)[0];
   if (defect !== void 0) return defect;
   return cause;
 };
@@ -337,7 +324,7 @@ var yieldEffect = (strategy) => {
     case "none":
       return Effect3.void;
     case "microtask":
-      return Effect3.yieldNow();
+      return Effect3.yieldNow;
     case "macrotask":
       return Effect3.promise(
         () => new Promise((resolve) => {
@@ -430,6 +417,67 @@ var ModuleCache = class {
     const scope = Effect3.runSync(Scope2.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 (isDevEnv() || Logix3.Debug.isDevtoolsEnabled()) {
+          void this.runtime.runPromise(
+            Logix3.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(
+            Logix3.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",
@@ -445,7 +493,7 @@ var ModuleCache = class {
     };
     this.scheduleGC(key, entry);
     const startedAt = performance.now();
-    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(Effect3.zipRight(factory(scope)));
+    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(Effect3.flatMap(() => factory(scope)));
     const fiber = this.runtime.runFork(buildEffect);
     entry.fiber = fiber;
     const promise = this.runtime.runPromise(Fiber.await(fiber)).then((exit) => {
@@ -641,6 +689,49 @@ var ModuleCache = class {
       throw error;
     }
   }
+  warmSync(key, factory, gcTime, ownerId, options) {
+    const existing = this.entries.get(key);
+    if (existing) {
+      if (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(Scope2.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(Scope2.close(scope, Exit2.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) {
@@ -670,6 +761,38 @@ var ModuleCache = class {
     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",
@@ -685,7 +808,7 @@ var ModuleCache = class {
     this.scheduleGC(key, entry);
     this.entries.set(key, entry);
     const startedAt = performance.now();
-    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(Effect3.zipRight(factory(scope)));
+    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(Effect3.flatMap(() => factory(scope)));
     const fiber = this.runtime.runFork(buildEffect);
     entry.fiber = fiber;
     const promise = this.runtime.runPromise(Fiber.await(fiber)).then((exit) => {

package/dist/{chunk-ZANGOPUQ.js → chunk-NKYV44OG.js}

@@ -24,10 +24,7 @@ var makeReactPlatform = Effect.gen(function* () {
   const resetRef = yield* Ref.make([]);
   return new ReactPlatformImpl(suspendRef, resumeRef, resetRef);
 });
-var ReactPlatformLayer = Layer.scoped(
-  Platform.tag,
-  makeReactPlatform
-);
+var ReactPlatformLayer = Layer.effect(Platform.tag, makeReactPlatform);
 
 export {
   ReactPlatformLayer

package/dist/{chunk-G5MRIFKK.js → chunk-SDQF3WRT.js}

@@ -1,13 +1,14 @@
 import {
   useModule,
   useRuntime
-} from "./chunk-UFFCJGSZ.js";
+} from "./chunk-E3ZXST5F.js";
 import {
   RuntimeProvider
-} from "./chunk-JXAJTWSZ.js";
+} from "./chunk-XSGDBJXD.js";
 
 // src/ModuleScope.ts
 import React from "react";
+import { Effect } from "effect";
 import * as Logix from "@logixjs/core";
 var makeModuleScope = (handle, defaults) => {
   const Context = React.createContext(null);
@@ -17,7 +18,9 @@ var makeModuleScope = (handle, defaults) => {
   };
   const getRegistryOrThrow = (runtime, where) => {
     try {
-      const registry = runtime.runSync(Logix.ScopeRegistry.ScopeRegistryTag);
+      const registry = runtime.runSync(
+        Effect.service(Logix.ScopeRegistry.ScopeRegistryTag).pipe(Effect.orDie)
+      );
       if (!registry) {
         throw new Error("ScopeRegistry service is undefined");
       }
@@ -61,10 +64,7 @@ var makeModuleScope = (handle, defaults) => {
     const runtime = useRuntime();
     const registry = getRegistryOrThrow(runtime, "[ModuleScope.Bridge]");
     const scopedRuntime = registry.get(scopeId, Logix.ScopeRegistry.ScopedRuntimeTag);
-    const moduleRuntime = registry.get(
-      scopeId,
-      moduleToken
-    );
+    const moduleRuntime = registry.get(scopeId, moduleToken);
     if (!scopedRuntime || !moduleRuntime) {
       throw new Error(
         `[ModuleScope.Bridge] Scope "${scopeId}" is not registered (or has been disposed). Ensure you have a corresponding <ModuleScope.Provider options={{ scopeId }}> mounted.`

package/dist/{chunk-JXAJTWSZ.js → chunk-XSGDBJXD.js}

@@ -4,16 +4,16 @@ import {
   getModuleCache,
   isDevEnv,
   useLayerBinding
-} from "./chunk-2WFULYPJ.js";
+} from "./chunk-L7KTYBXN.js";
 
 // src/internal/provider/RuntimeProvider.tsx
 import React2, { useContext, useEffect as useEffect2, useMemo, useState as useState2 } from "react";
-import { Layer as Layer2, Effect as Effect2, Cause, FiberRef, Context as Context2, Scope } from "effect";
+import { Cause, Effect as Effect2, Layer as Layer2, Scope, ServiceMap as ServiceMap2 } from "effect";
 import * as Logix2 from "@logixjs/core";
 
 // src/internal/provider/config.ts
-import { Config, Context, Effect, Layer, Option } from "effect";
-var ReactRuntimeConfigTag = class extends Context.Tag("@logixjs/react/RuntimeConfig")() {
+import { Config, Effect, Layer, Option, ServiceMap } from "effect";
+var ReactRuntimeConfigTag = class extends ServiceMap.Service()("@logixjs/react/RuntimeConfig") {
 };
 var DEFAULT_CONFIG = {
   gcTime: 500,
@@ -394,6 +394,9 @@ var RuntimeProvider = ({
 }) => {
   const parent = useContext(RuntimeContext);
   const baseRuntime = useRuntimeResolution(runtime, parent);
+  const providerStartedAtRef = React2.useRef(performance.now());
+  const providerReadyAtRef = React2.useRef(void 0);
+  const didReportProviderGatingRef = React2.useRef(false);
   const resolvedPolicy = useMemo(
     () => resolveRuntimeProviderPolicy({
       policy,
@@ -403,6 +406,20 @@ var RuntimeProvider = ({
   );
   const onErrorRef = React2.useRef(onError);
   onErrorRef.current = onError;
+  const hasTickServices = useMemo(() => {
+    try {
+      Logix2.InternalContracts.getRuntimeStore(baseRuntime);
+      return true;
+    } catch {
+      return false;
+    }
+  }, [baseRuntime]);
+  const { binding: tickBinding } = useLayerBinding(
+    baseRuntime,
+    Logix2.InternalContracts.tickServicesLayer,
+    !hasTickServices,
+    onErrorRef.current
+  );
   const { binding: layerBinding } = useLayerBinding(baseRuntime, layer, Boolean(layer), onErrorRef.current);
   const onErrorSink = useMemo(() => {
     if (!onError) return null;
@@ -419,7 +436,7 @@ var RuntimeProvider = ({
             moduleId: event.moduleId,
             instanceId: event.instanceId,
             runtimeLabel: event.runtimeLabel
-          }).pipe(Effect2.catchAllCause(() => Effect2.void));
+          }).pipe(Effect2.catchCause(() => Effect2.void));
         }
         if (event.type === "diagnostic" && event.severity === "error") {
           return handler(
@@ -438,7 +455,7 @@ var RuntimeProvider = ({
               instanceId: event.instanceId,
               runtimeLabel: event.runtimeLabel
             }
-          ).pipe(Effect2.catchAllCause(() => Effect2.void));
+          ).pipe(Effect2.catchCause(() => Effect2.void));
         }
         return Effect2.void;
       }
@@ -453,25 +470,23 @@ var RuntimeProvider = ({
       return layerBinding.debugSinks;
     }
     try {
-      return baseRuntime.runSync(
-        FiberRef.get(Logix2.Debug.internal.currentDebugSinks)
-      );
+      return baseRuntime.runSync(Effect2.service(Logix2.Debug.internal.currentDebugSinks).pipe(Effect2.orDie));
     } catch {
       return [];
     }
   }, [baseRuntime, layerBinding, onErrorSink]);
   const runtimeWithBindings = useMemo(
-    () => layerBinding || onErrorSink ? createRuntimeAdapter(
+    () => tickBinding || layerBinding || onErrorSink ? createRuntimeAdapter(
       baseRuntime,
-      layerBinding ? [layerBinding.context] : [],
-      layerBinding ? [layerBinding.scope] : [],
-      layerBinding ? [layerBinding.loggers] : [],
-      layerBinding ? [layerBinding.logLevel] : [],
+      [...tickBinding ? [tickBinding.context] : [], ...layerBinding ? [layerBinding.context] : []],
+      [...tickBinding ? [tickBinding.scope] : [], ...layerBinding ? [layerBinding.scope] : []],
+      layerBinding ? [layerBinding.loggers] : tickBinding ? [tickBinding.loggers] : [],
+      layerBinding ? [layerBinding.logLevel] : tickBinding ? [tickBinding.logLevel] : [],
       [
         onErrorSink ? [onErrorSink, ...inheritedDebugSinks] : layerBinding ? layerBinding.debugSinks : []
       ]
     ) : baseRuntime,
-    [baseRuntime, inheritedDebugSinks, layerBinding, onErrorSink]
+    [baseRuntime, inheritedDebugSinks, layerBinding, onErrorSink, tickBinding]
   );
   const didReportSyncConfigSnapshotRef = React2.useRef(false);
   const [configState, setConfigState] = useState2(() => {
@@ -576,11 +591,47 @@ var RuntimeProvider = ({
     }),
     [runtimeWithBindings, configState, resolvedPolicy]
   );
+  const isTickServicesReady = hasTickServices || tickBinding !== null;
   const isLayerReady = !layer || layerBinding !== null;
   const isConfigReady = configState.loaded;
   const resolveFallback = (phase) => {
     return resolveRuntimeProviderFallback({ fallback, phase, policyMode: resolvedPolicy.mode });
   };
+  const preloadCache = useMemo(
+    () => getModuleCache(runtimeWithBindings, configState.snapshot, configState.version),
+    [runtimeWithBindings, configState.snapshot, configState.version]
+  );
+  const syncWarmPreloadReady = 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) => Layer2.buildWithScope(handle.layer, scope).pipe(
+          Effect2.map((context) => ServiceMap2.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) => Scope.provide(scope)(Effect2.service(handle).pipe(Effect2.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] = useState2(false);
   useEffect2(() => {
     if (resolvedPolicy.mode !== "defer") {
@@ -594,6 +645,10 @@ var RuntimeProvider = ({
     if (resolvedPolicy.mode !== "defer") {
       return;
     }
+    if (syncWarmPreloadReady) {
+      setDeferReady(true);
+      return;
+    }
     setDeferReady(false);
     if (!resolvedPolicy.preload) {
       setDeferReady(true);
@@ -603,7 +658,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);
@@ -621,13 +676,14 @@ var RuntimeProvider = ({
           const moduleId = handle.module?.id ?? "ModuleImpl";
           const key2 = resolvedPolicy.preload.keysByModuleId.get(moduleId) ?? getPreloadKeyForModuleId(moduleId);
           const factory2 = (scope) => Layer2.buildWithScope(handle.layer, scope).pipe(
-            Effect2.map((context) => Context2.get(context, handle.module))
+            Effect2.map((context) => ServiceMap2.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;
@@ -652,14 +708,13 @@ var RuntimeProvider = ({
         }
         const tagId = handle.id ?? "ModuleTag";
         const key = resolvedPolicy.preload.keysByTagId.get(tagId) ?? getPreloadKeyForTagId(tagId);
-        const factory = (scope) => handle.pipe(
-          Scope.extend(scope)
-        );
+        const factory = (scope) => Scope.provide(scope)(Effect2.service(handle).pipe(Effect2.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;
@@ -697,7 +752,7 @@ var RuntimeProvider = ({
       if (cancelled) return;
       if (onErrorRef.current) {
         runtimeWithBindings.runFork(
-          onErrorRef.current(Cause.die(error), { source: "provider", phase: "provider.layer.build" }).pipe(Effect2.catchAllCause(() => Effect2.void))
+          onErrorRef.current(Cause.die(error), { source: "provider", phase: "provider.layer.build" }).pipe(Effect2.catchCause(() => Effect2.void))
         );
       }
       setDeferReady(true);
@@ -730,12 +785,54 @@ var RuntimeProvider = ({
       release();
     };
   }, [resolvedPolicy.mode, deferReady]);
-  const isReady = 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();
+  }
+  useEffect2(() => {
+    if (!isReady) {
+      return;
+    }
+    if (didReportProviderGatingRef.current) {
+      return;
+    }
+    let diagnosticsLevel = "off";
+    try {
+      diagnosticsLevel = runtimeWithBindings.runSync(
+        Effect2.service(Logix2.Debug.internal.currentDiagnosticsLevel).pipe(Effect2.orDie)
+      );
+    } catch {
+      diagnosticsLevel = 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(
+      Logix2.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__ */ jsx2(