@logixjs/react 0.1.0

package/dist/chunk-JXAJTWSZ.js

@@ -0,0 +1,773 @@
+import {
+  RuntimeContext,
+  createRuntimeAdapter,
+  getModuleCache,
+  isDevEnv,
+  useLayerBinding
+} from "./chunk-2WFULYPJ.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 * 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")() {
+};
+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: Config.number("logix.react.gc_time").pipe(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: Config.option(Config.number("logix.react.init_timeout_ms")),
+  /**
+   * Delay (ms) for low-priority notification scheduling.
+   * - Roughly "defer to the next frame" cadence (default 16ms).
+   */
+  lowPriorityDelayMs: Config.number("logix.react.low_priority_delay_ms").pipe(
+    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: Config.number("logix.react.low_priority_max_delay_ms").pipe(
+    Config.withDefault(DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50)
+  )
+};
+var ReactModuleConfig = {
+  gcTime: Effect.gen(function* () {
+    const override = yield* Effect.serviceOption(ReactRuntimeConfigTag);
+    if (Option.isSome(override)) {
+      return override.value.gcTime;
+    }
+    const value = yield* ReactModuleConfigFromEnv.gcTime;
+    return value;
+  }),
+  initTimeoutMs: Effect.gen(function* () {
+    const override = yield* Effect.serviceOption(ReactRuntimeConfigTag);
+    if (Option.isSome(override)) {
+      const v = override.value.initTimeoutMs;
+      return v === void 0 ? Option.none() : Option.some(v);
+    }
+    const opt = yield* ReactModuleConfigFromEnv.initTimeoutMs;
+    return opt;
+  }),
+  lowPriorityDelayMs: Effect.gen(function* () {
+    const override = yield* Effect.serviceOption(ReactRuntimeConfigTag);
+    if (Option.isSome(override)) {
+      return override.value.lowPriorityDelayMs ?? DEFAULT_CONFIG.lowPriorityDelayMs ?? 16;
+    }
+    const value = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
+    return value;
+  }),
+  lowPriorityMaxDelayMs: Effect.gen(function* () {
+    const override = yield* Effect.serviceOption(ReactRuntimeConfigTag);
+    if (Option.isSome(override)) {
+      return override.value.lowPriorityMaxDelayMs ?? DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50;
+    }
+    const value = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
+    return value;
+  })
+};
+var ReactRuntimeConfigSnapshot = {
+  load: Effect.gen(function* () {
+    const runtimeOverride = yield* Effect.serviceOption(ReactRuntimeConfigTag);
+    if (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 = Option.getOrUndefined(envInitTimeoutOpt);
+    const envLowPriorityDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
+    const envLowPriorityMaxDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
+    const fromConfig = envGcTime !== DEFAULT_CONFIG.gcTime || 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
+import { useEffect, useState } from "react";
+import * as Logix from "@logixjs/core";
+
+// 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
+import { Fragment, jsx, jsxs } from "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] = useState(0);
+  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__ */ 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__ */ jsxs("div", { children: [
+          message,
+          " ",
+          elapsedMs,
+          "ms"
+        ] }),
+        /* @__PURE__ */ 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 (!isDevEnv()) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(DefaultRuntimeFallback, { phase: args.phase, policyMode: args.policyMode });
+};
+var recordFallbackDuration = (args) => {
+  if (!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 (!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 }) => {
+  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__ */ jsx(Fragment, { children });
+};
+var FallbackProbeNoop = ({ children }) => /* @__PURE__ */ jsx(Fragment, { children });
+var FallbackProbe = (props) => {
+  const enabled = isDevEnv() || Logix.Debug.isDevtoolsEnabled();
+  const Impl = enabled ? FallbackProbeEnabled : FallbackProbeNoop;
+  return /* @__PURE__ */ jsx(Impl, { ...props });
+};
+
+// 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
+import { jsx as jsx2 } from "react/jsx-runtime";
+var SYNC_CONFIG_OVER_BUDGET_BY_RUNTIME = /* @__PURE__ */ new WeakMap();
+var RuntimeProvider = ({
+  layer,
+  runtime,
+  children,
+  fallback,
+  policy,
+  onError
+}) => {
+  const parent = useContext(RuntimeContext);
+  const baseRuntime = useRuntimeResolution(runtime, parent);
+  const resolvedPolicy = useMemo(
+    () => resolveRuntimeProviderPolicy({
+      policy,
+      parentPolicy: parent?.policy ?? null
+    }),
+    [policy, parent?.policy]
+  );
+  const onErrorRef = React2.useRef(onError);
+  onErrorRef.current = onError;
+  const { binding: layerBinding } = useLayerBinding(baseRuntime, layer, Boolean(layer), onErrorRef.current);
+  const onErrorSink = useMemo(() => {
+    if (!onError) return null;
+    const sink = {
+      record: (event) => {
+        const handler = onErrorRef.current;
+        if (!handler) {
+          return Effect2.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(Effect2.catchAllCause(() => Effect2.void));
+        }
+        if (event.type === "diagnostic" && event.severity === "error") {
+          return handler(
+            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(Effect2.catchAllCause(() => Effect2.void));
+        }
+        return Effect2.void;
+      }
+    };
+    return sink;
+  }, [Boolean(onError)]);
+  const inheritedDebugSinks = useMemo(() => {
+    if (!onErrorSink) {
+      return [];
+    }
+    if (layerBinding) {
+      return layerBinding.debugSinks;
+    }
+    try {
+      return baseRuntime.runSync(
+        FiberRef.get(Logix2.Debug.internal.currentDebugSinks)
+      );
+    } catch {
+      return [];
+    }
+  }, [baseRuntime, layerBinding, onErrorSink]);
+  const runtimeWithBindings = 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 = React2.useRef(false);
+  const [configState, setConfigState] = useState2(() => {
+    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" };
+    }
+  });
+  useEffect2(() => {
+    if (configState.loadMode !== "sync") {
+      return;
+    }
+    if (didReportSyncConfigSnapshotRef.current) {
+      return;
+    }
+    didReportSyncConfigSnapshotRef.current = true;
+    void runtimeWithBindings.runPromise(
+      Logix2.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]);
+  useEffect2(() => {
+    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(
+        Logix2.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 = 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] = useState2(false);
+  useEffect2(() => {
+    if (resolvedPolicy.mode !== "defer") {
+      setDeferReady(false);
+      return;
+    }
+    setDeferReady(false);
+  }, [resolvedPolicy.mode]);
+  const preloadCancelsRef = React2.useRef(null);
+  useEffect2(() => {
+    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) => Layer2.buildWithScope(handle.layer, scope).pipe(
+            Effect2.map((context) => Context2.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(
+            Logix2.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(
+          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(
+          Logix2.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(Cause.die(error), { source: "provider", phase: "provider.layer.build" }).pipe(Effect2.catchAllCause(() => Effect2.void))
+        );
+      }
+      setDeferReady(true);
+    });
+    return () => {
+      cancelled = true;
+      preloadCancelsRef.current = null;
+      for (const cancel of allCancels) cancel();
+    };
+  }, [resolvedPolicy, isLayerReady, isConfigReady, runtimeWithBindings, configState, onErrorRef]);
+  useEffect2(() => {
+    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__ */ jsx2(
+      FallbackProbe,
+      {
+        runtime: runtimeWithBindings,
+        phase: "provider.gating",
+        policyMode: resolvedPolicy.mode,
+        blockers,
+        children: resolveFallback("provider.gating")
+      }
+    );
+  }
+  const content = resolvedPolicy.mode === "sync" ? children : /* @__PURE__ */ jsx2(
+    React2.Suspense,
+    {
+      fallback: /* @__PURE__ */ jsx2(FallbackProbe, { runtime: runtimeWithBindings, phase: "react.suspense", policyMode: resolvedPolicy.mode, children: resolveFallback("react.suspense") }),
+      children
+    }
+  );
+  return React2.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;
+};
+
+export {
+  RuntimeProvider
+};