@logixjs/react 0.1.1 → 1.0.1

package/dist/{chunk-G2LX7WWQ.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 Logix3 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,42 +274,54 @@ 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/RuntimeExternalStore.ts
-import * as Logix2 from "@logixjs/core";
+import * as Logix3 from "@logixjs/core";
 import { Fiber, Stream } from "effect";
 var storesByRuntime = /* @__PURE__ */ new WeakMap();
 var getStoreMapForRuntime = (runtime) => {
@@ -306,8 +333,8 @@ var getStoreMapForRuntime = (runtime) => {
 };
 var makeModuleInstanceKey = (moduleId, instanceId) => `${moduleId}::${instanceId}`;
 var makeReadQueryTopicKey = (moduleInstanceKey, selectorId) => `${moduleInstanceKey}::rq:${selectorId}`;
-var getRuntimeStore = (runtime) => Logix2.InternalContracts.getRuntimeStore(runtime);
-var getHostScheduler = (runtime) => Logix2.InternalContracts.getHostScheduler(runtime);
+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);
@@ -331,6 +358,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;
@@ -415,7 +444,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();
@@ -429,18 +489,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 };
@@ -507,7 +556,7 @@ function useSelector(handle, selector, equalityFn) {
   const moduleRuntime = useModuleRuntime(handle);
   const actualSelector = selector ?? ((state) => state);
   const selectorReadQuery = useMemo3(
-    () => typeof selector === "function" ? Logix3.ReadQuery.compile(selector) : void 0,
+    () => typeof selector === "function" ? Logix4.ReadQuery.compile(selector) : void 0,
     [selector]
   );
   const actualEqualityFn = useMemo3(() => {
@@ -545,7 +594,7 @@ function useSelector(handle, selector, equalityFn) {
     actualEqualityFn
   );
   useEffect3(() => {
-    if (!isDevEnv() && !Logix3.Debug.isDevtoolsEnabled()) {
+    if (!isDevEnv() && !Logix4.Debug.isDevtoolsEnabled()) {
       return;
     }
     const instanceId = moduleRuntime.instanceId;
@@ -561,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 = Logix3.Debug.record({
+    const effect = Logix4.Debug.record({
       type: "trace:react-selector",
       moduleId: moduleRuntime.moduleId,
       instanceId,
@@ -585,11 +634,11 @@ function useSelector(handle, selector, equalityFn) {
 
 // src/internal/hooks/useModule.ts
 import React2 from "react";
-import * as Logix5 from "@logixjs/core";
-import { Context, Effect as Effect3, 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 Logix4 from "@logixjs/core";
+import * as Logix5 from "@logixjs/core";
 var getOrCreateWeakMap = (map, key, make) => {
   const cached = map.get(key);
   if (cached) return cached;
@@ -613,7 +662,7 @@ var resolveImportedModuleRef = (runtime, parentRuntime, module) => {
   if (cached) {
     return cached;
   }
-  const importsScope = Logix4.InternalContracts.getImportsScope(parentRuntime);
+  const importsScope = Logix5.InternalContracts.getImportsScope(parentRuntime);
   const childRuntime = importsScope.get(module);
   if (childRuntime) {
     const dispatch = Object.assign(
@@ -699,8 +748,8 @@ var useStableId = () => {
 
 // src/internal/hooks/useModule.ts
 var isModuleImpl = (handle) => Boolean(handle) && typeof handle === "object" && handle._tag === "ModuleImpl";
-var isModule = (handle) => Logix5.Module.hasImpl(handle);
-var isModuleDef = (handle) => Logix5.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);
@@ -724,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),
@@ -752,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(
-        Effect3.map(
-          (context) => Context.get(context, normalizedHandle.module)
+      () => (scope) => Layer2.buildWithScope(Layer2.fresh(normalizedHandle.layer), scope).pipe(
+        Effect4.map(
+          (context) => ServiceMap.get(context, normalizedHandle.module)
         )
       ),
       [normalizedHandle]
@@ -764,26 +814,56 @@ function useModule(handle, selectorOrOptions, equalityFn) {
         return baseFactory;
       }
       return (scope) => baseFactory(scope).pipe(
-        Effect3.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;
@@ -793,22 +873,22 @@ function useModule(handle, selectorOrOptions, equalityFn) {
     if (!label) {
       return;
     }
-    const effect = Logix5.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() && !Logix5.Debug.isDevtoolsEnabled()) {
+    if (!isDevEnv() && !Logix6.Debug.isDevtoolsEnabled()) {
       return;
     }
     if (!runtime.instanceId) {
       return;
     }
-    const effect = Logix5.Debug.record({
+    const effect = Logix6.Debug.record({
       type: "trace:react-render",
       moduleId: runtime.moduleId,
       instanceId: runtime.instanceId,
@@ -818,7 +898,7 @@ function useModule(handle, selectorOrOptions, equalityFn) {
       }
     });
     runtimeBase.runFork(effect);
-  }, [runtimeBase, runtime]);
+  });
   if (selector) {
     if (isModuleImpl(normalizedHandle)) {
       return useSelector(runtime, selector, equalityFn);

package/dist/{chunk-JC3R6GII.js → chunk-KYWW4KMQ.js}

@@ -1,14 +1,14 @@
 import {
   useDispatch,
   useLocalModule
-} from "./chunk-WOTNVLCD.js";
+} from "./chunk-6NLXTHZ7.js";
 import {
   useModule,
   useSelector
-} from "./chunk-G2LX7WWQ.js";
+} from "./chunk-E3ZXST5F.js";
 import {
   RuntimeProvider
-} from "./chunk-2M6MDNVT.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