@logixjs/react 0.1.0

package/dist/RuntimeProvider.cjs

@@ -0,0 +1,1618 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/RuntimeProvider.ts
+var RuntimeProvider_exports = {};
+__export(RuntimeProvider_exports, {
+  RuntimeProvider: () => RuntimeProvider
+});
+module.exports = __toCommonJS(RuntimeProvider_exports);
+
+// src/internal/provider/RuntimeProvider.tsx
+var import_react4 = __toESM(require("react"), 1);
+var import_effect5 = require("effect");
+var Logix5 = __toESM(require("@logixjs/core"), 1);
+
+// src/internal/provider/ReactContext.ts
+var import_react = require("react");
+var RuntimeContext = (0, import_react.createContext)(null);
+
+// src/internal/provider/config.ts
+var import_effect = require("effect");
+var ReactRuntimeConfigTag = class extends import_effect.Context.Tag("@logixjs/react/RuntimeConfig")() {
+};
+var DEFAULT_CONFIG = {
+  gcTime: 500,
+  initTimeoutMs: void 0,
+  lowPriorityDelayMs: 16,
+  lowPriorityMaxDelayMs: 50
+};
+var DEFAULT_CONFIG_SNAPSHOT = {
+  gcTime: DEFAULT_CONFIG.gcTime,
+  initTimeoutMs: DEFAULT_CONFIG.initTimeoutMs,
+  lowPriorityDelayMs: DEFAULT_CONFIG.lowPriorityDelayMs ?? 16,
+  lowPriorityMaxDelayMs: DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50,
+  source: "default"
+};
+var ReactModuleConfigFromEnv = {
+  /**
+   * Default gcTime (ms) used as the idle keep-alive time for ModuleCache.
+   * - Applies when not explicitly specified in useModule(options.gcTime).
+   * - Default: 500ms (StrictMode jitter protection).
+   */
+  gcTime: import_effect.Config.number("logix.react.gc_time").pipe(import_effect.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_effect.Config.option(import_effect.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_effect.Config.number("logix.react.low_priority_delay_ms").pipe(
+    import_effect.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_effect.Config.number("logix.react.low_priority_max_delay_ms").pipe(
+    import_effect.Config.withDefault(DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50)
+  )
+};
+var ReactModuleConfig = {
+  gcTime: import_effect.Effect.gen(function* () {
+    const override = yield* import_effect.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect.Option.isSome(override)) {
+      return override.value.gcTime;
+    }
+    const value = yield* ReactModuleConfigFromEnv.gcTime;
+    return value;
+  }),
+  initTimeoutMs: import_effect.Effect.gen(function* () {
+    const override = yield* import_effect.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect.Option.isSome(override)) {
+      const v = override.value.initTimeoutMs;
+      return v === void 0 ? import_effect.Option.none() : import_effect.Option.some(v);
+    }
+    const opt = yield* ReactModuleConfigFromEnv.initTimeoutMs;
+    return opt;
+  }),
+  lowPriorityDelayMs: import_effect.Effect.gen(function* () {
+    const override = yield* import_effect.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect.Option.isSome(override)) {
+      return override.value.lowPriorityDelayMs ?? DEFAULT_CONFIG.lowPriorityDelayMs ?? 16;
+    }
+    const value = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
+    return value;
+  }),
+  lowPriorityMaxDelayMs: import_effect.Effect.gen(function* () {
+    const override = yield* import_effect.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect.Option.isSome(override)) {
+      return override.value.lowPriorityMaxDelayMs ?? DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50;
+    }
+    const value = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
+    return value;
+  })
+};
+var ReactRuntimeConfigSnapshot = {
+  load: import_effect.Effect.gen(function* () {
+    const runtimeOverride = yield* import_effect.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect.Option.isSome(runtimeOverride)) {
+      return {
+        gcTime: runtimeOverride.value.gcTime,
+        initTimeoutMs: runtimeOverride.value.initTimeoutMs,
+        lowPriorityDelayMs: runtimeOverride.value.lowPriorityDelayMs ?? DEFAULT_CONFIG.lowPriorityDelayMs ?? 16,
+        lowPriorityMaxDelayMs: runtimeOverride.value.lowPriorityMaxDelayMs ?? DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50,
+        source: "runtime"
+      };
+    }
+    const envGcTime = yield* ReactModuleConfigFromEnv.gcTime;
+    const envInitTimeoutOpt = yield* ReactModuleConfigFromEnv.initTimeoutMs;
+    const envInitTimeout = import_effect.Option.getOrUndefined(envInitTimeoutOpt);
+    const envLowPriorityDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
+    const envLowPriorityMaxDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
+    const fromConfig = envGcTime !== DEFAULT_CONFIG.gcTime || import_effect.Option.isSome(envInitTimeoutOpt) || envLowPriorityDelayMs !== (DEFAULT_CONFIG.lowPriorityDelayMs ?? 16) || envLowPriorityMaxDelayMs !== (DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50);
+    if (fromConfig) {
+      return {
+        gcTime: envGcTime,
+        initTimeoutMs: envInitTimeout,
+        lowPriorityDelayMs: envLowPriorityDelayMs,
+        lowPriorityMaxDelayMs: envLowPriorityMaxDelayMs,
+        source: "config"
+      };
+    }
+    return DEFAULT_CONFIG_SNAPSHOT;
+  })
+};
+
+// src/internal/provider/fallback.tsx
+var import_react2 = require("react");
+var Logix = __toESM(require("@logixjs/core"), 1);
+
+// src/internal/provider/env.ts
+var import_Env = require("@logixjs/core/Env");
+
+// src/internal/provider/docs.ts
+var LOGIX_DOCS_PREFIX_ENV = "LOGIX_DOCS_PREFIX";
+var stripTrailingSlashes = (value) => value.replace(/\/+$/, "");
+var ensureLeadingSlash = (value) => value.startsWith("/") ? value : `/${value}`;
+var getProcessEnvString = (key) => {
+  try {
+    const env = globalThis?.process?.env;
+    const value = env?.[key];
+    return typeof value === "string" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var getLocationOrigin = () => {
+  try {
+    const origin = globalThis?.location?.origin;
+    return typeof origin === "string" && origin.length > 0 ? origin : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var getDocsRootPrefix = () => {
+  const raw = getProcessEnvString(LOGIX_DOCS_PREFIX_ENV);
+  const fromEnv = raw ? stripTrailingSlashes(raw.trim()) : void 0;
+  if (fromEnv && fromEnv.length > 0) {
+    if (/^https?:\/\//i.test(fromEnv)) {
+      return fromEnv;
+    }
+    const origin2 = getLocationOrigin();
+    if (origin2) {
+      return stripTrailingSlashes(`${origin2}${ensureLeadingSlash(fromEnv)}`);
+    }
+    return fromEnv;
+  }
+  const origin = getLocationOrigin();
+  return origin ? `${origin}/zh/docs` : void 0;
+};
+var resolveLogixDocsUrl = (docsPath) => {
+  const docsRoot = getDocsRootPrefix();
+  const path = ensureLeadingSlash(docsPath);
+  if (docsRoot) {
+    return `${stripTrailingSlashes(docsRoot)}${path}`;
+  }
+  return path;
+};
+var getFallbackWarningDocsUrl = () => resolveLogixDocsUrl("/guide/essentials/react-integration");
+var getFallbackWarningDocsPrefixEnv = () => LOGIX_DOCS_PREFIX_ENV;
+
+// src/internal/provider/fallback.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var FALLBACK_WARNED_BY_RUNTIME = /* @__PURE__ */ new WeakMap();
+var DEFAULT_FALLBACK_WARN_THRESHOLD_MS = 100;
+var DEFAULT_FALLBACK_FLASH_HINT_MIN_MS = 16;
+var DefaultRuntimeFallback = ({ phase, policyMode }) => {
+  const [elapsedMs, setElapsedMs] = (0, import_react2.useState)(0);
+  (0, import_react2.useEffect)(() => {
+    const start = performance.now();
+    const interval = setInterval(() => {
+      setElapsedMs(Math.round(performance.now() - start));
+    }, 100);
+    return () => {
+      clearInterval(interval);
+    };
+  }, []);
+  const message = phase === "provider.gating" ? "Logix \u8FD0\u884C\u65F6\u51C6\u5907\u4E2D\u2026" : "Logix \u6A21\u5757\u89E3\u6790\u4E2D\u2026";
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      style: {
+        padding: 12,
+        fontSize: 13,
+        lineHeight: 1.4,
+        opacity: 0.85,
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace'
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+          message,
+          " ",
+          elapsedMs,
+          "ms"
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { marginTop: 6, opacity: 0.8 }, children: [
+          "policy.mode=",
+          policyMode,
+          "\uFF08\u60F3\u201C\u65E0\u7B49\u5F85\u201D\u2192 sync\uFF1B\u60F3\u201C\u5C11\u95EA\u70C1\u201D\u2192 defer+preload\uFF09"
+        ] })
+      ]
+    }
+  );
+};
+var resolveRuntimeProviderFallback = (args) => {
+  if (args.fallback !== void 0) {
+    return args.fallback;
+  }
+  if (!(0, import_Env.isDevEnv)()) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultRuntimeFallback, { phase: args.phase, policyMode: args.policyMode });
+};
+var recordFallbackDuration = (args) => {
+  if (!(0, import_Env.isDevEnv)() && !Logix.Debug.isDevtoolsEnabled()) {
+    return;
+  }
+  void args.runtime.runPromise(
+    Logix.Debug.record({
+      type: "trace:react.fallback.duration",
+      data: {
+        phase: args.phase,
+        policyMode: args.policyMode,
+        durationMs: Math.round(args.durationMs * 100) / 100,
+        blockers: args.blockers
+      }
+    })
+  ).catch(() => {
+  });
+};
+var warnFallbackDuration = (args) => {
+  if (!(0, import_Env.isDevEnv)()) {
+    return;
+  }
+  const warnThresholdMs = DEFAULT_FALLBACK_WARN_THRESHOLD_MS;
+  const isVisibleLong = args.durationMs >= warnThresholdMs;
+  const isFlashHint = args.phase === "react.suspense" && args.policyMode !== "sync" && args.durationMs >= DEFAULT_FALLBACK_FLASH_HINT_MIN_MS && args.durationMs < warnThresholdMs;
+  if (!isVisibleLong && !isFlashHint) {
+    return;
+  }
+  const runtimeKey = args.runtime;
+  const warned = FALLBACK_WARNED_BY_RUNTIME.get(runtimeKey) ?? /* @__PURE__ */ new Set();
+  FALLBACK_WARNED_BY_RUNTIME.set(runtimeKey, warned);
+  const kind = isVisibleLong ? "visible" : "flash";
+  const dedupeKey = `${kind}::${args.phase}::${args.policyMode}::${args.blockers ?? "none"}`;
+  if (warned.has(dedupeKey)) {
+    return;
+  }
+  warned.add(dedupeKey);
+  const docs = `Docs: ${getFallbackWarningDocsUrl()} (override via ${getFallbackWarningDocsPrefixEnv()})`;
+  const header = isVisibleLong ? "[Logix][React] Fallback visible" : "[Logix][React] Suspense fallback resolved quickly";
+  const hint = (() => {
+    if (isVisibleLong) {
+      if (args.phase === "provider.gating") {
+        return args.policyMode === "sync" ? 'Hint: You are using policy.mode="sync", but the provider is still waiting for dependencies (layer/config). Consider using "suspend"/"defer" (default UX), and/or make your layer/config ready earlier.' : "Hint: RuntimeProvider is still waiting for dependencies (layer/config/preload). Provide a fallback, use defer+preload, or switch to sync (deterministic, but render-blocking).";
+      }
+      return 'Hint: Suspense fallback is active (module resolve). If you prefer fewer fallbacks, use defer+preload; if you prefer \u201Cno waiting\u201D, switch to policy.mode="sync" (moves the cost to render-time sync blocking).';
+    }
+    return 'Hint: This fallback is short. If you want to eliminate the flicker, consider policy.mode="sync" (but it may introduce render-time sync blocking).';
+  })();
+  const example = (() => {
+    if (isFlashHint) {
+      return 'Example: <RuntimeProvider policy={{ mode: "sync" }} fallback={<Loading />}>\u2026</RuntimeProvider>';
+    }
+    return args.phase === "provider.gating" ? 'Example: <RuntimeProvider policy={{ mode: "defer", preload: [MyImpl] }} fallback={<Loading />}>\u2026</RuntimeProvider>' : 'Example: <RuntimeProvider policy={{ mode: "sync" }} fallback={<Loading />}>\u2026</RuntimeProvider>';
+  })();
+  const log = isVisibleLong ? console.warn : console.info;
+  log(
+    header,
+    `(${Math.round(args.durationMs)}ms)`,
+    "\n",
+    `phase=${args.phase}`,
+    "\n",
+    `policy.mode=${args.policyMode}`,
+    args.blockers ? `
+blockers=${args.blockers}` : "",
+    "\n",
+    hint,
+    "\n",
+    example,
+    "\n",
+    docs
+  );
+};
+var FallbackProbeEnabled = ({ runtime, phase, policyMode, blockers, children }) => {
+  (0, import_react2.useEffect)(() => {
+    const startedAt = performance.now();
+    return () => {
+      const durationMs = performance.now() - startedAt;
+      recordFallbackDuration({ runtime, phase, policyMode, durationMs, blockers });
+      warnFallbackDuration({ runtime, phase, policyMode, durationMs, blockers });
+    };
+  }, [runtime, phase, policyMode, blockers]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+};
+var FallbackProbeNoop = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+var FallbackProbe = (props) => {
+  const enabled = (0, import_Env.isDevEnv)() || Logix.Debug.isDevtoolsEnabled();
+  const Impl = enabled ? FallbackProbeEnabled : FallbackProbeNoop;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Impl, { ...props });
+};
+
+// src/internal/provider/runtimeBindings.ts
+var import_react3 = require("react");
+var import_effect2 = require("effect");
+var Logix2 = __toESM(require("@logixjs/core"), 1);
+var toErrorString = (error) => error instanceof Error ? error.stack ?? error.message : String(error);
+var debugScopeCloseFailure = (error) => {
+  if (!(0, import_Env.isDevEnv)()) return;
+  console.debug("[RuntimeProvider] Scope.close failed", toErrorString(error));
+};
+var useLayerBinding = (runtime, layer, enabled, onError) => {
+  const activeBindingRef = (0, import_react3.useRef)(null);
+  const [state, setState] = (0, import_react3.useState)(() => ({
+    binding: null,
+    isLoading: enabled && !!layer,
+    runtime,
+    layer,
+    enabled
+  }));
+  (0, import_react3.useEffect)(() => {
+    if (!enabled || !layer) {
+      const current2 = activeBindingRef.current;
+      if (current2) {
+        activeBindingRef.current = null;
+        void runtime.runPromise(import_effect2.Scope.close(current2.scope, import_effect2.Exit.void)).catch(debugScopeCloseFailure);
+      }
+      setState((prev) => {
+        if (prev.binding === null && prev.isLoading === false && prev.layer === void 0 && prev.enabled === enabled) {
+          return prev;
+        }
+        return {
+          binding: null,
+          isLoading: false,
+          runtime: prev.runtime,
+          layer: void 0,
+          enabled
+        };
+      });
+      return;
+    }
+    const current = activeBindingRef.current;
+    if (current && current.runtime === runtime && current.layer === layer && current.enabled === enabled) {
+      setState({
+        binding: current,
+        isLoading: false,
+        runtime,
+        layer,
+        enabled
+      });
+      return;
+    }
+    const previousBinding = current ?? state.binding;
+    if ((0, import_Env.isDevEnv)() && previousBinding && previousBinding.layer !== layer && enabled && layer) {
+      console.warn(
+        "[RuntimeProvider] Rebuilding layer due to a new layer reference. Memoize the Layer in the caller to avoid repeated rebuilds and resource churn."
+      );
+    }
+    if (current) {
+      activeBindingRef.current = null;
+      void runtime.runPromise(import_effect2.Scope.close(current.scope, import_effect2.Exit.void)).catch(debugScopeCloseFailure);
+    }
+    let cancelled = false;
+    setState({
+      binding: null,
+      isLoading: true,
+      runtime,
+      layer,
+      enabled
+    });
+    const newScope = import_effect2.Effect.runSync(import_effect2.Scope.make());
+    const buildEffect = import_effect2.Effect.gen(function* () {
+      const context = yield* import_effect2.Layer.buildWithScope(layer, newScope);
+      const applyEnv = (effect) => import_effect2.Effect.mapInputContext(
+        import_effect2.Scope.extend(effect, newScope),
+        (parent) => import_effect2.Context.merge(parent, context)
+      );
+      const loggers = yield* applyEnv(import_effect2.FiberRef.get(import_effect2.FiberRef.currentLoggers));
+      const logLevel = yield* applyEnv(import_effect2.FiberRef.get(import_effect2.FiberRef.currentLogLevel));
+      const debugSinks = yield* applyEnv(
+        import_effect2.FiberRef.get(Logix2.Debug.internal.currentDebugSinks)
+      );
+      return { context, loggers, logLevel, debugSinks };
+    });
+    const assignBinding = (result) => {
+      if (cancelled) {
+        return runtime.runPromise(import_effect2.Scope.close(newScope, import_effect2.Exit.void)).catch(debugScopeCloseFailure);
+      }
+      const previous = activeBindingRef.current;
+      const newBinding = {
+        context: result.context,
+        loggers: result.loggers,
+        logLevel: result.logLevel,
+        debugSinks: result.debugSinks,
+        scope: newScope,
+        runtime,
+        layer,
+        enabled
+      };
+      activeBindingRef.current = newBinding;
+      setState({
+        binding: newBinding,
+        isLoading: false,
+        runtime,
+        layer,
+        enabled
+      });
+      if (previous) {
+        return runtime.runPromise(import_effect2.Scope.close(previous.scope, import_effect2.Exit.void)).catch(debugScopeCloseFailure);
+      }
+      return Promise.resolve();
+    };
+    let builtSync = false;
+    try {
+      const result = runtime.runSync(buildEffect);
+      builtSync = true;
+      void assignBinding(result);
+    } catch {
+    }
+    if (!builtSync) {
+      void runtime.runPromise(buildEffect).then(assignBinding).catch((error) => {
+        if (onError) {
+          const cause = import_effect2.Cause.die(error);
+          runtime.runFork(
+            onError(cause, { source: "provider", phase: "provider.layer.build" }).pipe(
+              import_effect2.Effect.catchAllCause(() => import_effect2.Effect.void)
+            )
+          );
+        }
+        void runtime.runPromise(import_effect2.Scope.close(newScope, import_effect2.Exit.void)).catch(debugScopeCloseFailure);
+        if (!cancelled) {
+          console.error("[RuntimeProvider] Failed to build layer", error);
+          setState({
+            binding: null,
+            isLoading: false,
+            runtime,
+            layer,
+            enabled
+          });
+        }
+      });
+    }
+    return () => {
+      cancelled = true;
+      const current2 = activeBindingRef.current;
+      if (current2) {
+        activeBindingRef.current = null;
+        void runtime.runPromise(import_effect2.Scope.close(current2.scope, import_effect2.Exit.void)).catch(debugScopeCloseFailure);
+        return;
+      }
+      void runtime.runPromise(import_effect2.Scope.close(newScope, import_effect2.Exit.void)).catch(debugScopeCloseFailure);
+    };
+  }, [runtime, layer, enabled, onError]);
+  const isCurrentBinding = state.binding !== null && state.runtime === runtime && state.layer === layer && state.enabled === enabled && enabled && !!layer;
+  return {
+    binding: isCurrentBinding ? state.binding : null,
+    isLoading: isCurrentBinding ? state.isLoading : enabled && !!layer
+  };
+};
+var createRuntimeAdapter = (runtime, contexts, scopes, loggerSets, logLevels, debugSinks) => {
+  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_effect2.Effect.mapInputContext(
+        acc,
+        (parent) => import_effect2.Context.merge(parent, ctx)
+      ),
+      scopes.reduceRight(
+        (acc, scope) => import_effect2.Scope.extend(acc, scope),
+        effect
+      )
+    )
+  );
+  const applyLoggers = (effect) => {
+    const last = loggerSets.length > 0 ? loggerSets[loggerSets.length - 1] : null;
+    const logLevel = logLevels.length > 0 ? logLevels[logLevels.length - 1] : null;
+    const sinks = debugSinks.length > 0 ? debugSinks[debugSinks.length - 1] : null;
+    let result = effect;
+    if (last) {
+      result = import_effect2.Effect.locally(import_effect2.FiberRef.currentLoggers, last)(result);
+    }
+    if (logLevel) {
+      result = import_effect2.Effect.locally(import_effect2.FiberRef.currentLogLevel, logLevel)(result);
+    }
+    if (sinks && sinks.length > 0) {
+      result = import_effect2.Effect.locally(
+        Logix2.Debug.internal.currentDebugSinks,
+        sinks
+      )(result);
+    }
+    return result;
+  };
+  const adapted = {
+    ...runtime,
+    runFork: (effect, options) => runtime.runFork(applyLoggers(applyContexts(effect)), options),
+    runPromise: (effect, options) => runtime.runPromise(applyLoggers(applyContexts(effect)), options),
+    runPromiseExit: (effect, options) => runtime.runPromiseExit(applyLoggers(applyContexts(effect)), options),
+    runSync: (effect) => runtime.runSync(applyLoggers(applyContexts(effect))),
+    runSyncExit: (effect) => runtime.runSyncExit(applyLoggers(applyContexts(effect))),
+    runCallback: (effect, options) => runtime.runCallback(applyLoggers(applyContexts(effect)), options)
+  };
+  return adapted;
+};
+
+// src/internal/store/ModuleCache.ts
+var Logix4 = __toESM(require("@logixjs/core"), 1);
+var import_effect4 = require("effect");
+
+// src/internal/store/perfWorkloads.ts
+var Logix3 = __toESM(require("@logixjs/core"), 1);
+var import_effect3 = require("effect");
+var PerfCounterStateSchema = import_effect3.Schema.Struct({
+  value: import_effect3.Schema.Number
+});
+var PerfCounterActions = {
+  inc: import_effect3.Schema.Void
+};
+var PerfListScopeRowSchema = import_effect3.Schema.Struct({
+  id: import_effect3.Schema.String,
+  warehouseId: import_effect3.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 GLOBAL_YIELD_BUDGET_MEMORY_KEY = "__LOGIX_REACT_YIELD_BUDGET_MEMORY__";
+var getGlobalYieldBudgetMemory = () => {
+  const root = globalThis;
+  const existing = root[GLOBAL_YIELD_BUDGET_MEMORY_KEY];
+  if (existing && existing.byRuntime instanceof WeakMap) {
+    return existing;
+  }
+  const created = { byRuntime: /* @__PURE__ */ new WeakMap() };
+  root[GLOBAL_YIELD_BUDGET_MEMORY_KEY] = created;
+  return created;
+};
+var getStatsMapForRuntime = (runtime) => {
+  const global = getGlobalYieldBudgetMemory();
+  const cached = global.byRuntime.get(runtime);
+  if (cached) return cached;
+  const created = /* @__PURE__ */ new Map();
+  global.byRuntime.set(runtime, created);
+  return created;
+};
+var quantile = (sorted, q) => {
+  if (sorted.length === 0) return Number.NaN;
+  const clamped = Math.min(1, Math.max(0, q));
+  const idx = Math.floor(clamped * (sorted.length - 1));
+  return sorted[idx];
+};
+var p95 = (samplesMs) => {
+  if (samplesMs.length === 0) return Number.NaN;
+  const sorted = samplesMs.slice().sort((a, b) => a - b);
+  return quantile(sorted, 0.95);
+};
+var YieldBudgetMemory = {
+  shouldYield(args) {
+    const budgetMs = args.policy?.onlyWhenOverBudgetMs;
+    if (budgetMs === void 0) {
+      return { shouldYield: true, reason: "budgetDisabled", p95Ms: void 0 };
+    }
+    const byKey = getStatsMapForRuntime(args.runtime);
+    const stats = byKey.get(args.workloadKey) ?? { seen: false, samplesMs: [] };
+    if (!byKey.has(args.workloadKey)) {
+      byKey.set(args.workloadKey, stats);
+    }
+    if (!stats.seen) {
+      stats.seen = true;
+      return { shouldYield: true, reason: "firstRun", p95Ms: void 0 };
+    }
+    if (stats.samplesMs.length === 0) {
+      return { shouldYield: true, reason: "insufficientSamples", p95Ms: void 0 };
+    }
+    const p95Ms = p95(stats.samplesMs);
+    if (!Number.isFinite(p95Ms)) {
+      return { shouldYield: true, reason: "insufficientSamples", p95Ms: void 0 };
+    }
+    return p95Ms > budgetMs ? { shouldYield: true, reason: "overBudget", p95Ms } : { shouldYield: false, reason: "underBudget", p95Ms };
+  },
+  record(args) {
+    if (!Number.isFinite(args.durationMs) || args.durationMs < 0) return;
+    const byKey = getStatsMapForRuntime(args.runtime);
+    const stats = byKey.get(args.workloadKey) ?? { seen: true, samplesMs: [] };
+    if (!byKey.has(args.workloadKey)) {
+      byKey.set(args.workloadKey, stats);
+    }
+    stats.samplesMs.push(args.durationMs);
+    if (stats.samplesMs.length > 20) {
+      stats.samplesMs.shift();
+    }
+  }
+};
+
+// src/internal/store/ModuleCache.ts
+var RUNTIME_CACHE = /* @__PURE__ */ new WeakMap();
+var DEFAULT_GC_DELAY_MS = 500;
+var ERROR_GC_DELAY_MS = 500;
+var DEFAULT_RENDER_SYNC_BLOCKING_WARN_THRESHOLD_MS = 5;
+var toErrorString2 = (error) => {
+  if (error instanceof Error) {
+    return error.stack ?? error.message;
+  }
+  return String(error);
+};
+var seenBestEffortFailures = /* @__PURE__ */ new Set();
+var debugBestEffortFailure = (label, error) => {
+  if (!(0, import_Env.isDevEnv)()) return;
+  const message = toErrorString2(error);
+  if (message.includes("ManagedRuntime disposed")) {
+    return;
+  }
+  const key = `${label}
+${message}`;
+  if (seenBestEffortFailures.has(key)) return;
+  seenBestEffortFailures.add(key);
+  console.debug(label, message);
+};
+var causeToUnknown = (cause) => {
+  const failure = import_effect4.Option.getOrUndefined(import_effect4.Cause.failureOption(cause));
+  if (failure !== void 0) return failure;
+  const defect = import_effect4.Option.getOrUndefined(import_effect4.Cause.dieOption(cause));
+  if (defect !== void 0) return defect;
+  return cause;
+};
+var yieldEffect = (strategy) => {
+  switch (strategy) {
+    case "none":
+      return import_effect4.Effect.void;
+    case "microtask":
+      return import_effect4.Effect.yieldNow();
+    case "macrotask":
+      return import_effect4.Effect.promise(
+        () => new Promise((resolve) => {
+          setTimeout(resolve, 0);
+        })
+      );
+  }
+};
+var decideYieldStrategy = (runtime, workloadKey, policy) => {
+  const baseStrategy = policy?.strategy ?? "microtask";
+  if (baseStrategy === "none") {
+    return { strategy: "none", reason: "disabled" };
+  }
+  const budgetMs = policy?.onlyWhenOverBudgetMs;
+  if (budgetMs === void 0) {
+    return { strategy: baseStrategy };
+  }
+  const decision = YieldBudgetMemory.shouldYield({ runtime, workloadKey, policy });
+  return decision.shouldYield ? { strategy: baseStrategy, reason: decision.reason, p95Ms: decision.p95Ms } : { strategy: "none", reason: decision.reason, p95Ms: decision.p95Ms };
+};
+var warnedSyncBlockingKeys = /* @__PURE__ */ new Set();
+var ModuleCache = class {
+  constructor(runtime, gcDelayMs = DEFAULT_GC_DELAY_MS) {
+    this.runtime = runtime;
+    this.gcDelayMs = gcDelayMs;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  scheduleGC(key, entry) {
+    if (entry.gcTimeout) {
+      return;
+    }
+    const delay = entry.gcTime;
+    if (!Number.isFinite(delay)) {
+      return;
+    }
+    const timeoutMs = delay <= 0 ? 0 : delay;
+    entry.gcTimeout = setTimeout(() => {
+      const current = this.entries.get(key);
+      if (!current || current !== entry) {
+        return;
+      }
+      current.gcTimeout = void 0;
+      if (current.refCount > 0 || current.preloadRefCount > 0) {
+        return;
+      }
+      if (current.status === "pending") {
+        this.scheduleGC(key, current);
+        return;
+      }
+      void this.runtime.runPromise(import_effect4.Scope.close(current.scope, import_effect4.Exit.void)).catch((error) => {
+        debugBestEffortFailure("[ModuleCache] Scope.close failed", error);
+      });
+      void this.runtime.runPromise(
+        Logix4.Debug.record({
+          type: "trace:react.module-instance",
+          moduleId: current.ownerId,
+          instanceId: current.value?.instanceId,
+          data: {
+            event: "gc",
+            key
+          }
+        })
+      ).catch((error) => {
+        debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
+      });
+      this.entries.delete(key);
+    }, timeoutMs);
+  }
+  read(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) {
+        console.error(
+          "[ModuleCache.read] resource key ownership mismatch:",
+          `key="${key}" previously owned by "${existing.ownerId}",`,
+          `but now requested by "${ownerId}".`
+        );
+        throw new Error(
+          `[ModuleCache.read] resource key "${key}" has already been claimed by module "${existing.ownerId}", but is now requested by module "${ownerId}". Within the same ManagedRuntime, a given key must not be shared across different ModuleImpl definitions. Please ensure each ModuleImpl uses a distinct key when sharing ModuleRuntime instances.`
+        );
+      }
+      if (existing.status === "pending") {
+        throw existing.promise;
+      }
+      if (existing.status === "error") {
+        throw existing.error;
+      }
+      return existing.value;
+    }
+    const scope = import_effect4.Effect.runSync(import_effect4.Scope.make());
+    const workloadKey = `${options?.entrypoint ?? "unknown"}::${ownerId ?? "unknown"}`;
+    const yieldDecision = decideYieldStrategy(this.runtime, workloadKey, options?.yield);
+    const entry = {
+      scope,
+      status: "pending",
+      // Placeholder; will be replaced immediately with the real Promise.
+      promise: Promise.resolve(null),
+      refCount: 0,
+      preloadRefCount: 0,
+      gcTime: gcTime ?? this.gcDelayMs,
+      ownerId,
+      createdBy: "read",
+      workloadKey,
+      yieldStrategy: yieldDecision.strategy
+    };
+    this.scheduleGC(key, entry);
+    const startedAt = performance.now();
+    const buildEffect = yieldEffect(yieldDecision.strategy).pipe(import_effect4.Effect.zipRight(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;
+      throw causeToUnknown(exit.cause);
+    });
+    promise.then((value) => {
+      entry.status = "success";
+      entry.value = value;
+      const durationMs = performance.now() - startedAt;
+      YieldBudgetMemory.record({ runtime: this.runtime, workloadKey, durationMs });
+      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: yieldDecision.strategy,
+              yieldReason: yieldDecision.reason,
+              yieldP95Ms: yieldDecision.p95Ms
+            }
+          })
+        ).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: entry.gcTime
+            }
+          })
+        ).catch((error) => {
+          debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
+        });
+      }
+      return value;
+    }).catch((error) => {
+      entry.status = "error";
+      entry.error = error;
+      entry.gcTime = ERROR_GC_DELAY_MS;
+      if (entry.gcTimeout) {
+        clearTimeout(entry.gcTimeout);
+        entry.gcTimeout = void 0;
+      }
+      this.scheduleGC(key, entry);
+      YieldBudgetMemory.record({
+        runtime: this.runtime,
+        workloadKey,
+        durationMs: performance.now() - startedAt
+      });
+      void this.runtime.runPromise(import_effect4.Scope.close(scope, import_effect4.Exit.fail(error))).catch((closeError) => {
+        debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
+      });
+      throw error;
+    });
+    this.entries.set(key, entry);
+    entry.promise = promise;
+    throw promise;
+  }
+  readSync(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) {
+        console.error(
+          "[ModuleCache.readSync] resource key ownership mismatch:",
+          `key="${key}" previously owned by "${existing.ownerId}",`,
+          `but now requested by "${ownerId}".`
+        );
+        throw new Error(
+          `[ModuleCache.readSync] resource key "${key}" has already been claimed by module "${existing.ownerId}", but is now requested by module "${ownerId}". Within the same ManagedRuntime, a given key must not be shared across different ModuleImpl definitions. Please ensure each ModuleImpl uses a distinct key when sharing ModuleRuntime instances.`
+        );
+      }
+      if (existing.status === "error") {
+        throw existing.error;
+      }
+      if (existing.status === "pending") {
+        throw new Error(
+          `[ModuleCache.readSync] encountered pending entry for key="${key}". This usually indicates that the same resource key is being used by both suspend:true (async) and sync consumers. Please either give different keys to async/sync callers, or stick to a single access mode for this resource.`
+        );
+      }
+      return existing.value;
+    }
+    const scope = this.runtime.runSync(import_effect4.Scope.make());
+    const startedAt = performance.now();
+    try {
+      const value = this.runtime.runSync(factory(scope));
+      const durationMs = performance.now() - startedAt;
+      const entry = {
+        scope,
+        status: "success",
+        promise: Promise.resolve(value),
+        value,
+        refCount: 0,
+        preloadRefCount: 0,
+        gcTime: gcTime ?? this.gcDelayMs,
+        ownerId,
+        createdBy: "read",
+        workloadKey: `${options?.entrypoint ?? "unknown"}::${ownerId ?? "unknown"}`,
+        yieldStrategy: "none"
+      };
+      this.scheduleGC(key, entry);
+      this.entries.set(key, entry);
+      if ((0, import_Env.isDevEnv)()) {
+        const threshold = options?.warnSyncBlockingThresholdMs ?? DEFAULT_RENDER_SYNC_BLOCKING_WARN_THRESHOLD_MS;
+        if (threshold > 0 && durationMs > threshold) {
+          const dedupeKey = `${options?.entrypoint ?? "unknown"}::${ownerId ?? "unknown"}::${key}`;
+          if (!warnedSyncBlockingKeys.has(dedupeKey)) {
+            warnedSyncBlockingKeys.add(dedupeKey);
+            const hint = options?.policyMode === "defer" ? 'Fix: \u5F53\u524D policy.mode="defer"\uFF1A\u8BF7\u68C0\u67E5\u8BE5\u6A21\u5757\u662F\u5426\u5728 policy.preload \u5217\u8868\u4E2D\uFF1B\u672A\u9884\u52A0\u8F7D\u7684\u6A21\u5757\u4ECD\u53EF\u80FD\u89E6\u53D1\u4E8C\u6B21 fallback \u6216\u540C\u6B65\u91CD\u6D3B\u3002' : 'Fix: \u5EFA\u8BAE\u5207\u6362\u5230 policy.mode="suspend"\uFF08\u9ED8\u8BA4\uFF09\uFF0C\u5E76\u63D0\u4F9B RuntimeProvider.fallback\uFF1B\u5FC5\u8981\u65F6\u542F\u7528 yield \u7B56\u7565\u3002';
+            const example = options?.policyMode === "defer" ? 'Example: <RuntimeProvider policy={{ mode: "defer", preload: [MyImpl] }} fallback={<Loading />}>\u2026</RuntimeProvider>' : 'Example: <RuntimeProvider policy={{ mode: "suspend" }} fallback={<Loading />}>\u2026</RuntimeProvider>';
+            const docs = "Docs: apps/docs/content/docs/guide/essentials/react-integration.md";
+            console.warn(
+              "[Logix][React] Render-phase sync blocking detected",
+              `(${Math.round(durationMs * 100) / 100}ms > ${threshold}ms)`,
+              "\n",
+              `entrypoint=${options?.entrypoint ?? "unknown"}`,
+              "\n",
+              `ownerId=${ownerId ?? "unknown"}`,
+              "\n",
+              `key=${key}`,
+              "\n",
+              hint,
+              "\n",
+              example,
+              "\n",
+              docs
+            );
+          }
+        }
+      }
+      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: "sync",
+              key,
+              durationMs: Math.round(durationMs * 100) / 100,
+              yieldStrategy: "none"
+            }
+          })
+        ).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: "sync",
+              gcTime: entry.gcTime
+            }
+          })
+        ).catch((error) => {
+          debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
+        });
+      }
+      return value;
+    } catch (error) {
+      void this.runtime.runPromise(import_effect4.Scope.close(scope, import_effect4.Exit.fail(error))).catch((closeError) => {
+        debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
+      });
+      const entry = {
+        scope,
+        status: "error",
+        promise: Promise.reject(error),
+        error,
+        refCount: 0,
+        preloadRefCount: 0,
+        gcTime: ERROR_GC_DELAY_MS,
+        ownerId,
+        createdBy: "read",
+        workloadKey: `${options?.entrypoint ?? "unknown"}::${ownerId ?? "unknown"}`,
+        yieldStrategy: "none"
+      };
+      this.scheduleGC(key, entry);
+      this.entries.set(key, entry);
+      throw error;
+    }
+  }
+  preload(key, factory, options) {
+    const existing = this.entries.get(key);
+    if (existing) {
+      if (existing.status === "success") {
+        existing.preloadRefCount += 1;
+        return {
+          promise: Promise.resolve(existing.value),
+          cancel: () => {
+            this.cancelPreload(key, existing);
+          }
+        };
+      }
+      if (existing.status === "error") {
+        return { promise: Promise.reject(existing.error), cancel: () => {
+        } };
+      }
+      existing.preloadRefCount += 1;
+      return {
+        promise: existing.promise,
+        cancel: () => {
+          this.cancelPreload(key, existing);
+        }
+      };
+    }
+    const scope = import_effect4.Effect.runSync(import_effect4.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 entry = {
+      scope,
+      status: "pending",
+      promise: Promise.resolve(null),
+      refCount: 0,
+      preloadRefCount: 1,
+      gcTime,
+      ownerId,
+      createdBy: "preload",
+      workloadKey,
+      yieldStrategy: yieldDecision.strategy
+    };
+    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 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;
+      throw causeToUnknown(exit.cause);
+    });
+    entry.promise = promise;
+    void promise.then((value) => {
+      entry.status = "success";
+      entry.value = value;
+      YieldBudgetMemory.record({
+        runtime: this.runtime,
+        workloadKey,
+        durationMs: performance.now() - startedAt
+      });
+    }).catch((error) => {
+      entry.status = "error";
+      entry.error = error;
+      entry.gcTime = ERROR_GC_DELAY_MS;
+      if (entry.gcTimeout) {
+        clearTimeout(entry.gcTimeout);
+        entry.gcTimeout = void 0;
+      }
+      this.scheduleGC(key, entry);
+      YieldBudgetMemory.record({
+        runtime: this.runtime,
+        workloadKey,
+        durationMs: performance.now() - startedAt
+      });
+      void this.runtime.runPromise(import_effect4.Scope.close(scope, import_effect4.Exit.fail(error))).catch((closeError) => {
+        debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
+      });
+    });
+    return {
+      promise,
+      cancel: () => {
+        this.cancelPreload(key, entry);
+      }
+    };
+  }
+  cancelPreload(key, entry) {
+    const current = this.entries.get(key);
+    if (!current || current !== entry) {
+      return;
+    }
+    entry.preloadRefCount = Math.max(0, entry.preloadRefCount - 1);
+    if (entry.preloadRefCount > 0) {
+      return;
+    }
+    if (entry.refCount > 0) {
+      return;
+    }
+    if (entry.status === "pending") {
+      if (entry.createdBy !== "preload") {
+        this.scheduleGC(key, entry);
+        return;
+      }
+      const running = entry.fiber;
+      entry.fiber = void 0;
+      this.entries.delete(key);
+      if (running) {
+        this.runtime.runFork(import_effect4.Fiber.interrupt(running));
+      }
+      void this.runtime.runPromise(import_effect4.Scope.close(entry.scope, import_effect4.Exit.void)).catch((closeError) => {
+        debugBestEffortFailure("[ModuleCache] Scope.close failed", closeError);
+      });
+      return;
+    }
+    if (entry.gcTimeout) {
+      clearTimeout(entry.gcTimeout);
+      entry.gcTimeout = void 0;
+    }
+    this.scheduleGC(key, entry);
+  }
+  /**
+   * Declares ownership of a resource after component commit.
+   * The returned function releases the reference during cleanup.
+   */
+  retain(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return () => {
+      };
+    }
+    entry.refCount += 1;
+    if (entry.gcTimeout) {
+      clearTimeout(entry.gcTimeout);
+      entry.gcTimeout = void 0;
+    }
+    return () => {
+      this.release(key);
+    };
+  }
+  release(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return;
+    }
+    entry.refCount -= 1;
+    if (entry.refCount > 0) {
+      return;
+    }
+    this.scheduleGC(key, entry);
+  }
+  dispose() {
+    for (const [key, entry] of this.entries) {
+      if (entry.gcTimeout) {
+        clearTimeout(entry.gcTimeout);
+      }
+      void this.runtime.runPromise(import_effect4.Scope.close(entry.scope, import_effect4.Exit.void)).catch((error) => {
+        debugBestEffortFailure("[ModuleCache] Scope.close failed", error);
+      });
+      this.entries.delete(key);
+    }
+  }
+};
+var getModuleCache = (runtime, config, version) => {
+  const cached = RUNTIME_CACHE.get(runtime);
+  if (cached && cached.version === version) {
+    return cached.cache;
+  }
+  if (cached) {
+    cached.cache.dispose();
+  }
+  const cache = new ModuleCache(runtime, config.gcTime);
+  RUNTIME_CACHE.set(runtime, { version, cache });
+  return cache;
+};
+
+// src/internal/provider/policy.ts
+var DEFAULT_PRELOAD_CONCURRENCY = 5;
+var DEFAULT_SYNC_BUDGET_MS = 5;
+var DEFAULT_YIELD_STRATEGY = "microtask";
+var isModuleImpl = (handle) => Boolean(handle) && typeof handle === "object" && handle._tag === "ModuleImpl";
+var isModuleTag = (handle) => {
+  if (!handle || typeof handle !== "object" && typeof handle !== "function") {
+    return false;
+  }
+  const candidate = handle;
+  return candidate._kind === "ModuleTag";
+};
+var getPreloadKeyForModuleId = (moduleId) => `preload:impl:${moduleId}`;
+var getPreloadKeyForTagId = (tagId) => `preload:tag:${tagId}`;
+var normalizeYieldPolicy = (policy) => ({
+  strategy: policy?.strategy ?? DEFAULT_YIELD_STRATEGY,
+  onlyWhenOverBudgetMs: policy?.onlyWhenOverBudgetMs
+});
+var normalizePreload = (preload) => {
+  if (!preload) return null;
+  const policy = Array.isArray(preload) ? { handles: preload } : preload;
+  const handles = [];
+  for (const handle of policy.handles ?? []) {
+    if (isModuleImpl(handle) || isModuleTag(handle)) {
+      handles.push(handle);
+    }
+  }
+  return {
+    handles,
+    concurrency: Math.max(1, policy.concurrency ?? DEFAULT_PRELOAD_CONCURRENCY),
+    yield: normalizeYieldPolicy(policy.yield)
+  };
+};
+var resolveRuntimeProviderPolicy = (args) => {
+  const inheritedMode = args.parentPolicy?.mode;
+  const mode = args.policy?.mode ?? (inheritedMode !== void 0 ? inheritedMode : "suspend");
+  const moduleResolveMode = mode === "sync" ? "sync" : "suspend";
+  const preload = mode === "defer" ? normalizePreload(args.policy?.preload) : null;
+  const keysByModuleId = /* @__PURE__ */ new Map();
+  const keysByTagId = /* @__PURE__ */ new Map();
+  if (preload) {
+    for (const handle of preload.handles) {
+      if (isModuleImpl(handle)) {
+        const moduleId = handle.module.id ?? "ModuleImpl";
+        keysByModuleId.set(moduleId, getPreloadKeyForModuleId(moduleId));
+      } else if (isModuleTag(handle)) {
+        const tagId = handle.id ?? "ModuleTag";
+        keysByTagId.set(tagId, getPreloadKeyForTagId(tagId));
+      }
+    }
+  }
+  return {
+    mode,
+    moduleImplMode: moduleResolveMode,
+    moduleTagMode: moduleResolveMode,
+    syncBudgetMs: Math.max(0, args.policy?.syncBudgetMs ?? args.parentPolicy?.syncBudgetMs ?? DEFAULT_SYNC_BUDGET_MS),
+    yield: normalizeYieldPolicy(args.policy?.yield ?? args.parentPolicy?.yield),
+    preload: preload ? {
+      ...preload,
+      keysByModuleId,
+      keysByTagId
+    } : null
+  };
+};
+
+// src/internal/provider/RuntimeProvider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var SYNC_CONFIG_OVER_BUDGET_BY_RUNTIME = /* @__PURE__ */ new WeakMap();
+var RuntimeProvider = ({
+  layer,
+  runtime,
+  children,
+  fallback,
+  policy,
+  onError
+}) => {
+  const parent = (0, import_react4.useContext)(RuntimeContext);
+  const baseRuntime = useRuntimeResolution(runtime, parent);
+  const resolvedPolicy = (0, import_react4.useMemo)(
+    () => resolveRuntimeProviderPolicy({
+      policy,
+      parentPolicy: parent?.policy ?? null
+    }),
+    [policy, parent?.policy]
+  );
+  const onErrorRef = import_react4.default.useRef(onError);
+  onErrorRef.current = onError;
+  const { binding: layerBinding } = useLayerBinding(baseRuntime, layer, Boolean(layer), onErrorRef.current);
+  const onErrorSink = (0, import_react4.useMemo)(() => {
+    if (!onError) return null;
+    const sink = {
+      record: (event) => {
+        const handler = onErrorRef.current;
+        if (!handler) {
+          return import_effect5.Effect.void;
+        }
+        if (event.type === "lifecycle:error") {
+          return handler(event.cause, {
+            source: "provider",
+            phase: "debug.lifecycle_error",
+            moduleId: event.moduleId,
+            instanceId: event.instanceId,
+            runtimeLabel: event.runtimeLabel
+          }).pipe(import_effect5.Effect.catchAllCause(() => import_effect5.Effect.void));
+        }
+        if (event.type === "diagnostic" && event.severity === "error") {
+          return handler(
+            import_effect5.Cause.fail({
+              code: event.code,
+              message: event.message,
+              hint: event.hint
+            }),
+            {
+              source: "provider",
+              phase: "debug.diagnostic_error",
+              code: event.code,
+              message: event.message,
+              hint: event.hint,
+              moduleId: event.moduleId,
+              instanceId: event.instanceId,
+              runtimeLabel: event.runtimeLabel
+            }
+          ).pipe(import_effect5.Effect.catchAllCause(() => import_effect5.Effect.void));
+        }
+        return import_effect5.Effect.void;
+      }
+    };
+    return sink;
+  }, [Boolean(onError)]);
+  const inheritedDebugSinks = (0, import_react4.useMemo)(() => {
+    if (!onErrorSink) {
+      return [];
+    }
+    if (layerBinding) {
+      return layerBinding.debugSinks;
+    }
+    try {
+      return baseRuntime.runSync(
+        import_effect5.FiberRef.get(Logix5.Debug.internal.currentDebugSinks)
+      );
+    } catch {
+      return [];
+    }
+  }, [baseRuntime, layerBinding, onErrorSink]);
+  const runtimeWithBindings = (0, import_react4.useMemo)(
+    () => layerBinding || onErrorSink ? createRuntimeAdapter(
+      baseRuntime,
+      layerBinding ? [layerBinding.context] : [],
+      layerBinding ? [layerBinding.scope] : [],
+      layerBinding ? [layerBinding.loggers] : [],
+      layerBinding ? [layerBinding.logLevel] : [],
+      [
+        onErrorSink ? [onErrorSink, ...inheritedDebugSinks] : layerBinding ? layerBinding.debugSinks : []
+      ]
+    ) : baseRuntime,
+    [baseRuntime, inheritedDebugSinks, layerBinding, onErrorSink]
+  );
+  const didReportSyncConfigSnapshotRef = import_react4.default.useRef(false);
+  const [configState, setConfigState] = (0, import_react4.useState)(() => {
+    const budgetMs = resolvedPolicy.syncBudgetMs;
+    if (budgetMs <= 0) {
+      return { snapshot: DEFAULT_CONFIG_SNAPSHOT, version: 1, loaded: false, loadMode: "none" };
+    }
+    if (SYNC_CONFIG_OVER_BUDGET_BY_RUNTIME.has(baseRuntime)) {
+      return { snapshot: DEFAULT_CONFIG_SNAPSHOT, version: 1, loaded: false, loadMode: "none" };
+    }
+    const startedAt = performance.now();
+    try {
+      const snapshot = runtimeWithBindings.runSync(
+        ReactRuntimeConfigSnapshot.load
+      );
+      const durationMs = performance.now() - startedAt;
+      const overBudget = durationMs > budgetMs;
+      if (overBudget) {
+        SYNC_CONFIG_OVER_BUDGET_BY_RUNTIME.set(baseRuntime, true);
+      }
+      return {
+        snapshot,
+        version: 1,
+        loaded: !overBudget,
+        loadMode: "sync",
+        syncDurationMs: durationMs,
+        syncOverBudget: overBudget
+      };
+    } catch {
+      return { snapshot: DEFAULT_CONFIG_SNAPSHOT, version: 1, loaded: false, loadMode: "none" };
+    }
+  });
+  (0, import_react4.useEffect)(() => {
+    if (configState.loadMode !== "sync") {
+      return;
+    }
+    if (didReportSyncConfigSnapshotRef.current) {
+      return;
+    }
+    didReportSyncConfigSnapshotRef.current = true;
+    void runtimeWithBindings.runPromise(
+      Logix5.Debug.record({
+        type: "trace:react.runtime.config.snapshot",
+        data: {
+          source: configState.snapshot.source,
+          mode: "sync",
+          durationMs: configState.syncDurationMs !== void 0 ? Math.round(configState.syncDurationMs * 100) / 100 : void 0,
+          syncBudgetMs: resolvedPolicy.syncBudgetMs,
+          overBudget: Boolean(configState.syncOverBudget)
+        }
+      })
+    ).catch(() => {
+    });
+  }, [configState, resolvedPolicy.syncBudgetMs, runtimeWithBindings]);
+  (0, import_react4.useEffect)(() => {
+    let cancelled = false;
+    runtimeWithBindings.runPromise(ReactRuntimeConfigSnapshot.load).then((snapshot) => {
+      if (cancelled) return;
+      setConfigState((prev) => {
+        const sameSnapshot = prev.snapshot.gcTime === snapshot.gcTime && prev.snapshot.initTimeoutMs === snapshot.initTimeoutMs && prev.snapshot.lowPriorityDelayMs === snapshot.lowPriorityDelayMs && prev.snapshot.lowPriorityMaxDelayMs === snapshot.lowPriorityMaxDelayMs && prev.snapshot.source === snapshot.source;
+        if (sameSnapshot && prev.loaded) {
+          return prev;
+        }
+        const cacheCriticalChanged = prev.snapshot.gcTime !== snapshot.gcTime;
+        return {
+          snapshot,
+          version: cacheCriticalChanged ? prev.version + 1 : prev.version,
+          loaded: true,
+          loadMode: "async"
+        };
+      });
+      void runtimeWithBindings.runPromise(
+        Logix5.Debug.record({
+          type: "trace:react.runtime.config.snapshot",
+          data: {
+            source: snapshot.source,
+            mode: "async"
+          }
+        })
+      ).catch(() => {
+      });
+    }).catch((error) => {
+      if (cancelled) return;
+      console.debug("[RuntimeProvider] Failed to load React runtime config snapshot, fallback to default.", error);
+      setConfigState((prev) => ({
+        snapshot: DEFAULT_CONFIG_SNAPSHOT,
+        version: prev.version,
+        loaded: true,
+        loadMode: "async"
+      }));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [runtimeWithBindings]);
+  const contextValue = (0, import_react4.useMemo)(
+    () => ({
+      runtime: runtimeWithBindings,
+      reactConfigSnapshot: configState.snapshot,
+      configVersion: configState.version,
+      policy: resolvedPolicy
+    }),
+    [runtimeWithBindings, configState, resolvedPolicy]
+  );
+  const isLayerReady = !layer || layerBinding !== null;
+  const isConfigReady = configState.loaded;
+  const resolveFallback = (phase) => {
+    return resolveRuntimeProviderFallback({ fallback, phase, policyMode: resolvedPolicy.mode });
+  };
+  const [deferReady, setDeferReady] = (0, import_react4.useState)(false);
+  (0, import_react4.useEffect)(() => {
+    if (resolvedPolicy.mode !== "defer") {
+      setDeferReady(false);
+      return;
+    }
+    setDeferReady(false);
+  }, [resolvedPolicy.mode]);
+  const preloadCancelsRef = import_react4.default.useRef(null);
+  (0, import_react4.useEffect)(() => {
+    if (resolvedPolicy.mode !== "defer") {
+      return;
+    }
+    setDeferReady(false);
+    if (!resolvedPolicy.preload) {
+      setDeferReady(true);
+      return;
+    }
+    if (!isLayerReady || !isConfigReady) {
+      return;
+    }
+    let cancelled = false;
+    const cache = getModuleCache(runtimeWithBindings, configState.snapshot, configState.version);
+    const preloadHandles = resolvedPolicy.preload.handles;
+    if (preloadHandles.length === 0) {
+      setDeferReady(true);
+      return;
+    }
+    const concurrency = Math.max(1, resolvedPolicy.preload.concurrency ?? DEFAULT_PRELOAD_CONCURRENCY);
+    const allCancels = /* @__PURE__ */ new Set();
+    preloadCancelsRef.current = allCancels;
+    const run = async () => {
+      const queue = preloadHandles.slice();
+      const runOne = async (handle) => {
+        if (cancelled) return;
+        const startedAt = performance.now();
+        if (handle?._tag === "ModuleImpl") {
+          const moduleId = handle.module?.id ?? "ModuleImpl";
+          const key2 = resolvedPolicy.preload.keysByModuleId.get(moduleId) ?? getPreloadKeyForModuleId(moduleId);
+          const factory2 = (scope) => import_effect5.Layer.buildWithScope(handle.layer, scope).pipe(
+            import_effect5.Effect.map((context) => import_effect5.Context.get(context, handle.module))
+          );
+          const op2 = cache.preload(key2, factory2, {
+            ownerId: moduleId,
+            yield: resolvedPolicy.preload.yield,
+            entrypoint: "react.runtime.preload",
+            policyMode: "defer"
+          });
+          allCancels.add(op2.cancel);
+          await op2.promise;
+          const durationMs2 = performance.now() - startedAt;
+          void runtimeWithBindings.runPromise(
+            Logix5.Debug.record({
+              type: "trace:react.module.preload",
+              moduleId,
+              data: {
+                mode: "defer",
+                handleKind: "ModuleImpl",
+                key: key2,
+                durationMs: Math.round(durationMs2 * 100) / 100,
+                concurrency,
+                yieldStrategy: resolvedPolicy.preload.yield.strategy,
+                yieldOnlyWhenOverBudgetMs: resolvedPolicy.preload.yield.onlyWhenOverBudgetMs
+              }
+            })
+          ).catch(() => {
+          });
+          return;
+        }
+        const tagId = handle.id ?? "ModuleTag";
+        const key = resolvedPolicy.preload.keysByTagId.get(tagId) ?? getPreloadKeyForTagId(tagId);
+        const factory = (scope) => handle.pipe(
+          import_effect5.Scope.extend(scope)
+        );
+        const op = cache.preload(key, factory, {
+          ownerId: tagId,
+          yield: resolvedPolicy.preload.yield,
+          entrypoint: "react.runtime.preload",
+          policyMode: "defer"
+        });
+        allCancels.add(op.cancel);
+        await op.promise;
+        const durationMs = performance.now() - startedAt;
+        void runtimeWithBindings.runPromise(
+          Logix5.Debug.record({
+            type: "trace:react.module.preload",
+            data: {
+              mode: "defer",
+              handleKind: "ModuleTag",
+              tokenId: tagId,
+              key,
+              durationMs: Math.round(durationMs * 100) / 100,
+              concurrency,
+              yieldStrategy: resolvedPolicy.preload.yield.strategy,
+              yieldOnlyWhenOverBudgetMs: resolvedPolicy.preload.yield.onlyWhenOverBudgetMs
+            }
+          })
+        ).catch(() => {
+        });
+      };
+      const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+        while (!cancelled) {
+          const next = queue.shift();
+          if (!next) return;
+          await runOne(next);
+        }
+      });
+      await Promise.all(workers);
+    };
+    run().then(() => {
+      if (cancelled) return;
+      setDeferReady(true);
+    }).catch((error) => {
+      if (cancelled) return;
+      if (onErrorRef.current) {
+        runtimeWithBindings.runFork(
+          onErrorRef.current(import_effect5.Cause.die(error), { source: "provider", phase: "provider.layer.build" }).pipe(import_effect5.Effect.catchAllCause(() => import_effect5.Effect.void))
+        );
+      }
+      setDeferReady(true);
+    });
+    return () => {
+      cancelled = true;
+      preloadCancelsRef.current = null;
+      for (const cancel of allCancels) cancel();
+    };
+  }, [resolvedPolicy, isLayerReady, isConfigReady, runtimeWithBindings, configState, onErrorRef]);
+  (0, import_react4.useEffect)(() => {
+    if (resolvedPolicy.mode !== "defer" || !deferReady) {
+      return;
+    }
+    const cancels = preloadCancelsRef.current;
+    if (!cancels || cancels.size === 0) {
+      return;
+    }
+    preloadCancelsRef.current = null;
+    const list = Array.from(cancels);
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      for (const cancel of list) cancel();
+    };
+    const timeout = setTimeout(release, 0);
+    return () => {
+      clearTimeout(timeout);
+      release();
+    };
+  }, [resolvedPolicy.mode, deferReady]);
+  const isReady = isLayerReady && isConfigReady && (resolvedPolicy.mode !== "defer" || deferReady);
+  if (!isReady) {
+    const blockersList = [
+      isLayerReady ? null : "layer",
+      isConfigReady ? null : "config",
+      resolvedPolicy.mode !== "defer" || deferReady ? null : "preload"
+    ].filter((x) => x !== null);
+    const blockers = blockersList.length > 0 ? blockersList.join("+") : void 0;
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      FallbackProbe,
+      {
+        runtime: runtimeWithBindings,
+        phase: "provider.gating",
+        policyMode: resolvedPolicy.mode,
+        blockers,
+        children: resolveFallback("provider.gating")
+      }
+    );
+  }
+  const content = resolvedPolicy.mode === "sync" ? children : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    import_react4.default.Suspense,
+    {
+      fallback: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(FallbackProbe, { runtime: runtimeWithBindings, phase: "react.suspense", policyMode: resolvedPolicy.mode, children: resolveFallback("react.suspense") }),
+      children
+    }
+  );
+  return import_react4.default.createElement(RuntimeContext.Provider, { value: contextValue }, content);
+};
+var useRuntimeResolution = (runtimeProp, parent) => {
+  const baseRuntime = runtimeProp ?? parent?.runtime;
+  if (!baseRuntime) {
+    throw new Error(
+      "[RuntimeProvider] Missing runtime.\n\nFix:\n- Provide `runtime` prop: <RuntimeProvider runtime={runtime}>...\n- Or nest under an ancestor RuntimeProvider that provides `runtime`.\n"
+    );
+  }
+  return baseRuntime;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeProvider
+});